Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@internal/core/cost_mapping.go`:
- Around line 19-25: The TokenCostMapping struct and its exported fields
(TokenCostMapping, RawDataKey, PricingField, Side, Unit) lack Go doc comments;
add concise doc comments above the TokenCostMapping type and each exported field
describing their purpose and types (e.g. RawDataKey is the raw data key string,
PricingField returns a pointer to a float64 from *ModelPricing, Side indicates
the CostSide, Unit indicates the CostUnit) so the package complies with
exported-symbol documentation guidelines and tooling.
- Around line 6-17: Add explicit zero-value sentinels for both enums to avoid
silent defaults: introduce CostSideUnknown as the first CostSide value and shift
CostSideInput/CostSideOutput to follow, and similarly introduce CostUnitUnknown
as the first CostUnit value and shift CostUnitPerMtok/CostUnitPerItem. Update
any validation logic (e.g., wherever TokenCostMapping instances are
validated/constructed) to reject Unknown values and ensure newly created
mappings set an explicit non-unknown CostSide and CostUnit. Reference the enum
types CostSide and CostUnit and the constants CostSideInput, CostSideOutput,
CostUnitPerMtok, CostUnitPerItem when making these changes so callers are
updated to use the new non-unknown values.

In `@internal/providers/factory.go`:
- Around line 107-127: CostRegistry currently builds informationalFields from
f.registrations (map iteration order is nondeterministic); before returning from
ProviderFactory.CostRegistry, sort the informationalFields slice to make output
deterministic (use sort.Strings) and ensure the package imports "sort" if not
present; update the function that references informationalFields (and the seen
map logic stays the same) so the only change is calling
sort.Strings(informationalFields) just prior to the return.

In `@internal/usage/cost.go`:
- Around line 113-127: Add explicit default branches to both switches that
handle m.Unit and m.Side (the switches around CostUnitPerMtok/CostUnitPerItem
and CostSideInput/CostSideOutput) so unknown enum values don't silently skip
cost accounting; in each default case emit a clear warning or error (using the
module's logger or return an error/panic path consistent with surrounding error
handling) that includes the unexpected enum value and context (e.g., the
meter/metric id and count) to surface misconfiguration early and ensure costs
are not silently dropped.
- Around line 29-55: RegisterCostMappings currently does a plain pointer write
to defaultCostRegistry while CalculateGranularCost reads it unsynchronized;
change publication to use atomic.Pointer[costRegistry] (or a sync.Once) so
readers see a safe, ordered store. Replace the package-level defaultCostRegistry
with an atomic.Pointer[costRegistry], update RegisterCostMappings to allocate
the new costRegistry and publish it with ptr.Store(newReg), and update
CalculateGranularCost (and any other readers) to use ptr.Load() and nil-check
before use; add the necessary import for sync/atomic and keep the costRegistry
type name unchanged.

In `@internal/usage/setup_test.go`:
- Around line 10-44: TestMain currently hardcodes provider cost mappings via
RegisterCostMappings which duplicates openai/anthropic/gemini/xai
Registration.CostMappings and can drift; replace the hardcoded maps by importing
each provider package and passing their authoritative Registration.CostMappings
(e.g., openai.Registration.CostMappings, anthropic.Registration.CostMappings,
gemini.Registration.CostMappings, xai.Registration.CostMappings) into
RegisterCostMappings inside TestMain so tests use the single source of truth;
keep the final shared slice (the second argument) as-is or build it from
provider vars if available.

---

Outside diff comments:
In `@CLAUDE.md`:
- Line 65: The startup sequence in CLAUDE.md is missing the cost-mapping
registration step; update the sequence to include the RegisterCostMappings step
between "Init providers (cache → async model load → background refresh →
router)" and "Init audit logging" to match app.go where RegisterCostMappings is
invoked; reference the RegisterCostMappings symbol (and app.go startup flow) to
ensure the doc order mirrors the code.

In `@internal/app/app.go`:
- Around line 217-222: Update the Shutdown method comment in internal/app/app.go
to include the missing fourth step (usage-tracking teardown) so the docstring
accurately reflects the implementation; explicitly list: (1) stop HTTP server,
(2) stop background refresh goroutine and clear cache, (3) stop/flush
usage-tracking, and (4) stop/flush audit logging, referencing the Shutdown
function so readers know the order matches the implementation.

In `@internal/providers/anthropic/anthropic.go`:
- Around line 503-510: convertEvent currently emits only prompt_tokens,
completion_tokens and total_tokens from event.Usage (anthropicUsage), which
omits CacheReadInputTokens and CacheCreationInputTokens and causes cache-related
CostMappings to be ignored in streaming mode; update the usage map built in
convertEvent (the block that checks if event.Usage != nil) to also include
"cache_read_input_tokens" and "cache_creation_input_tokens" (and keep
total_tokens calculation) using event.Usage.CacheReadInputTokens and
event.Usage.CacheCreationInputTokens, and apply the same change in
responsesStreamConverter where the EOF/response.completed handling emits
sc.cachedUsage so that sc.cachedUsage includes those two cache fields as well.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@internal/providers/anthropic/anthropic.go`:
- Around line 798-809: Extract the duplicated conditional cache-field injection
into a small helper (e.g., appendCacheFields(usageMap map[string]interface{}, u
*anthropicUsage) or reuse buildAnthropicRawUsage) and call it from both
streaming code paths where usageMap is constructed (the blocks that reference
usageMap, sc.cachedUsage.CacheReadInputTokens,
sc.cachedUsage.CacheCreationInputTokens and set responseData["usage"]); the
helper should add "cache_read_input_tokens" and "cache_creation_input_tokens"
only when the corresponding sc.cachedUsage fields are > 0 so you can replace the
duplicated if statements in both ChatCompletion and Responses streaming
locations with a single call to the helper.

In `@internal/usage/setup_test.go`:
- Around line 14-25: The test hard-codes
openai.Registration.InformationalFields, which diverges from production
(Factory.CostRegistry) that aggregates/deduplicates fields from all providers;
update TestMain to build the InformationalFields the same way production does by
importing the providers package and retrieving/merging the providers'
InformationalFields (e.g., via providers.Factory().CostRegistry() or iterating
providers.Registry) and pass that aggregated/deduped slice into
RegisterCostMappings instead of openai.Registration.InformationalFields; also
add the import "gomodel/internal/providers".