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

Inline comments:
In `@internal/admin/handler.go`:
- Around line 579-583: After Upsert, h.aliases.Get(name) may return false
unexpectedly; instead of silently returning 204, update the handler (the code
calling h.aliases.Get in internal/admin/handler.go) to handle this case
explicitly: either (A) log a warning/error that the alias was not found after
Upsert (include name and any request ID/context) and return a 5xx or 409 to
surface the race/refresh issue, or (B) change the Upsert flow to return the
created/updated alias object from the service and return that payload directly
from the handler (avoid an immediate re-fetch via h.aliases.Get). Locate the Get
call and the surrounding Upsert logic and implement one of these fixes, ensuring
logs include the unique alias name and enough context to debug.

In `@internal/aliases/service.go`:
- Around line 276-278: The background refresh call currently discards any error
from s.Refresh (spawned via refreshCtx, refreshCancel created with
context.WithTimeout), so change the code to capture the returned error from
s.Refresh(refreshCtx), call refreshCancel(), and then log the error (and/or emit
a metric) using the service's logger or metrics helper; ensure you reference
s.Refresh, refreshCtx, refreshCancel and include a clear log message that
includes the error and contextual info (e.g., which alias/service) so failed
refreshes are visible.

In `@internal/providers/registry.go`:
- Around line 472-478: LookupModel currently calls GetModel which returns an
info pointer after releasing the registry lock, then accesses info.Model
(metadata) without synchronization while EnrichModels may mutate it; to fix,
ensure the model data is copied while the registry lock is held: either modify
GetModel to return a deep-cloned core.Model (not the original info pointer)
while holding the lock, or add a new Registry method (e.g., GetModelCopy) that
acquires the same lock and returns a cloned model, and update
ModelRegistry.LookupModel to use that clone so it never reads info.Model after
unlocking; reference symbols: ModelRegistry.LookupModel, GetModel, EnrichModels,
info.Model.

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

Inline comments:
In `@internal/aliases/provider_test.go`:
- Around line 35-38: The StreamChatCompletion mock currently returns
io.NopCloser(nil) which will panic when Read is called; update
providerMock.StreamChatCompletion (and the other mock occurrence) to return a
non-nil, empty reader wrapped with io.NopCloser (for example use
bytes.NewReader([]byte{}) or strings.NewReader("") and wrap it with
io.NopCloser) and add the corresponding import (bytes or strings) so
stream-consuming tests won't panic.

In `@internal/providers/router.go`:
- Around line 392-412: The fast-path using providerTypeLister currently returns
typed.ProviderTypes() raw; update Router.providerTypes to normalize that slice
the same way as the fallback: call typed.ProviderTypes(), iterate the returned
[]string trimming whitespace (strings.TrimSpace), skip empty entries, dedupe
using a seen map[string]struct{}, collect unique values, sort.Strings on the
final slice, and return the sorted, normalized list so both branches produce
deterministic provider type ordering; reference the providerTypes method and the
providerTypeLister.ProviderTypes() call when making the change.

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

Inline comments:
In `@internal/admin/dashboard/static/css/dashboard.css`:
- Around line 876-880: The .audit-alias-badge rule uses an undefined CSS custom
property --accent-strong, causing the color declaration to be dropped; replace
the token with an existing defined variable (e.g., --accent or
--accent-foreground) or add --accent-strong to both theme palettes so the
variable exists. Update the .audit-alias-badge declaration to reference the
chosen existing token (or add the new --accent-strong variable into each theme
block) so the color resolves consistently across themes.

In `@internal/admin/dashboard/static/js/modules/aliases.js`:
- Around line 23-87: Add a new getter (e.g. scopedDisplayModels or
displayModelsForActiveCategory) that calls the existing displayModels and, when
this.activeCategory is set and not 'all', returns only rows whose category
matches the activeCategory; determine each row's category by preferring
row.provider_type, falling back to row.model?.object or (for alias rows)
alias.provider_type/target model.provider_type as used when building rows in
displayModels; then update table/count/empty-state bindings to use this new
getter instead of displayModels (also make the same change for the equivalent
block referenced at lines 89-105).

In `@internal/admin/dashboard/templates/index.html`:
- Around line 239-242: The filter input (x-model="modelFilter",
class="filter-input") lacks an accessible name; add a stable label by giving the
input an id (e.g., id="model-filter") and adding a corresponding <label
for="model-filter"> with descriptive text like "Filter models" or, if DOM
structure prevents a visible label, add an aria-label="Filter models by
provider, model, alias, or owner" to the same input; ensure the label text
matches the placeholder intent and that nothing else overwrites the id or
aria-label so assistive tech always has a stable name.

In `@internal/aliases/service_test.go`:
- Around line 81-88: The variable named `copy` in the function LookupModel is
shadowing the built-in `copy` identifier and is unclear; rename it (e.g.,
`result` or `modelRef`) and use that new name when returning the pointer (update
the line `copy := value` to `result := value` and return `&result, true`) so
LookupModel no longer shadows the built-in and reads clearly.
- Around line 31-38: The local variable named "copy" in the Get method of
memoryStore shadows Go's builtin copy function; rename it (e.g., result or
aliasRef) and return its address instead (update the declaration "copy := item"
to "result := item" and "return &copy, nil" to "return &result, nil") so the
builtin isn't shadowed and intent is clearer.

In `@internal/aliases/service.go`:
- Around line 215-220: The current flow calls s.store.Upsert (and similarly
s.store.Delete) then s.Refresh using the same request context, which can cause a
successful commit to be reported as an error if the context times out; instead,
after a successful s.store.Upsert(ctx, normalized) (or s.store.Delete(ctx,
normalized)), immediately update the in-memory snapshot/state using the
normalized value (or deletion) on the service (e.g., the same snapshot that
Refresh maintains) so the write is reflected even if Refresh later fails, and
keep s.Refresh(ctx) as a best-effort reconciliation step (log/ignore Refresh
errors rather than returning them as the write error).

In `@internal/server/request_model_resolution.go`:
- Around line 25-29: The current code only checks the outer
core.RoutableProvider for resolvedModelProvider, so wrapped providers (e.g.,
internal/guardrails/provider.go) bypass early alias resolution; fix by either
(A) updating wrappers like the guardrails wrapper to implement ResolveModel and
delegate to their wrapped provider, or (B) change the resolution logic in
request_model_resolution.go to unwrap wrappers until a resolvedModelProvider is
found before falling back to core.ParseModelSelector — for example iterate
peeling wrappers (via an Unwrap() method or known wrapper interface) and call
ResolveModel on the first resolver encountered, otherwise call
core.ParseModelSelector as the fallback.

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

Inline comments:
In `@internal/core/batch_preparation.go`:
- Around line 307-317: The current cloneBatchRequest implementation uses json
marshal/unmarshal which can be slow for large BatchRequest; change
cloneBatchRequest to perform a direct struct copy: check for nil req, copy the
top-level struct (cloned := *req), deep-clone the Requests slice by allocating
cloned.Requests = make([]BatchRequestItem, len(req.Requests)) and copy each item
while deep-cloning item.Body via a helper (e.g., CloneRawJSON), and deep-clone
ExtraFields by allocating a new map and copying entries; return &cloned and any
errors from the helper. Ensure you reference cloneBatchRequest, BatchRequest,
Requests, BatchRequestItem, ExtraFields, and the Body field when making these
changes.

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

Inline comments:
In `@internal/admin/dashboard/templates/index.html`:
- Around line 314-348: Extract the duplicated model row and action markup into a
single reusable template/component and replace the six repeated blocks with
references to it: create a shared template (e.g., "modelRowTemplate") or Alpine
component that accepts a row and exposes the same bindings used now
(row.display_name, row.is_alias, row.secondary_name, row.masking_alias,
aliasTargetLabel(row.masking_alias), row.model.metadata, formatPrice,
rowAnchorID(row), displayRowClass(row), aliasTogglingName, aliasDeletingName,
and the actions toggleAliasEnabled, openAliasEdit, deleteAlias), then update
each category table to x-for over filteredDisplayModels and instantiate that
shared template/component passing row so behavior and accessibility fixes only
need one edit.

In `@internal/guardrails/provider.go`:
- Around line 554-573: The function mergeBatchHints is duplicated; extract it
into a single shared helper (preserve the signature func mergeBatchHints(left,
right map[string]string) map[string]string) in a common package/module and
replace the duplicate implementations in both provider.go files with calls to
that helper; ensure the helper preserves current semantics (nil when both empty,
copies maps to avoid mutation), update imports/usages accordingly, and remove
the redundant local implementations (keep the helper name mergeBatchHints so
callers remain unchanged).

In `@internal/server/handlers.go`:
- Around line 659-665: The handler currently hard-fails in fileProviderTypes
when h.provider doesn't implement core.NativeFileProviderTypeLister, which
blocks explicit-provider uploads; change the flow so explicit provider
operations are allowed: 1) In the CreateFile request flow, only call
fileProviderTypes when the ?provider= query param is not supplied (i.e., when
routing needs inventory), and 2) make fileProviderTypes tolerant: if h.provider
does not implement core.NativeFileProviderTypeLister return (nil, nil) rather
than an error so callers can distinguish "no inventory available" from a real
error. Update references to fileProviderTypes and CreateFile accordingly.
- Around line 1917-1930: The current refresh logic in the handler overwrites
stored.Batch fields unconditionally (e.g., stored.Batch.Endpoint,
CompletionWindow, RequestCounts, Usage, Results, InProgressAt, CompletedAt,
FailedAt, CancellingAt, CancelledAt), which clears previously known values when
upstream returns partial responses; change each assignment to only copy the
upstream value when it is non-empty/non-zero/non-nil (or use firstNonEmpty
semantics similar to InputFileID) so stored values are preserved
otherwise—either add per-field conditional checks before assigning or introduce
a small helper (e.g., updateIfNonZero) and use it for Endpoint,
CompletionWindow, RequestCounts, Usage, Results and the timestamp fields to
avoid overwriting with empty upstream data.
- Around line 1575-1577: BatchResults is calling
cleanupStoredBatchRewrittenInputFile unconditionally which can delete rewrite
artifacts before the batch reaches a terminal state; modify the logic in the
BatchResults handler so cleanupStoredBatchRewrittenInputFile is only invoked
after confirming the stored batch has a terminal status (same terminal check
used by GetBatch/CancelBatch), e.g. wrap the call to
h.cleanupStoredBatchRewrittenInputFile(ctx, stored) in the terminal-status
condition (or call it after you determine stored.Status is terminal) before
proceeding to h.batchStore.Update(...).

---

Duplicate comments:
In `@internal/admin/dashboard/static/css/dashboard.css`:
- Around line 894-897: The CSS rule .audit-alias-badge uses an undefined custom
property --accent-strong, causing the color to be dropped; fix by either adding
a --accent-strong definition in the theme token blocks that define
--accent/--bg/--border or replace the reference in .audit-alias-badge with an
existing token (e.g., var(--accent) or your theme’s foreground token) so the
badge color is defined consistently across themes; update whichever you choose
in the theme definitions or in the .audit-alias-badge selector accordingly.

In `@internal/admin/dashboard/templates/index.html`:
- Around line 239-241: The models filter input currently only uses placeholder
text and loses its accessible name when populated; update the input element that
has x-model="modelFilter" and class="filter-input" to have a stable accessible
name by either adding a visible <label> tied to the input via id (e.g.,
id="model-filter" and <label for="model-filter">Models filter</label>) or by
adding an aria-label or aria-labelledby attribute (e.g., aria-label="Filter
models by provider, alias, or owner") so screen readers always have a persistent
label.

In `@internal/aliases/provider_test.go`:
- Around line 41-43: The stream mock providerMock.StreamChatCompletion returns
io.NopCloser(nil) which will panic when read; change it to return a non-nil,
empty reader (for example wrap an empty byte/string reader with io.NopCloser)
and update the other mock(s) at the same file (the similar stub around lines
55-57) so all io.NopCloser(nil) usages are replaced with a safe empty reader;
ensure the function signature (providerMock.StreamChatCompletion) still returns
(io.ReadCloser, error) and tests compile.

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

Inline comments:
In `@internal/admin/dashboard/templates/index.html`:
- Around line 305-319: The current template mounts six tables with x-show,
causing multiple mounted x-for blocks and duplicate row IDs from
rowAnchorID(row); replace those multiple x-show-wrapped tables with a single
table that is conditionally mounted using x-if (or render one shared table) and
pass it a category-scoped list (e.g., derive filteredDisplayModels by
activeCategory) so only the active table is mounted; ensure the template using
x-for="row in filteredDisplayModels" (and helpers rowAnchorID(row) and
displayRowClass(row)) is used once and receives the correct filtered list so IDs
remain unique and rows are not duplicated.

In `@internal/aliases/provider.go`:
- Around line 140-145: The Provider.NativeFileProviderTypes method is making the
alias wrapper always satisfy core.NativeFileProviderTypeLister and thus hides
when the inner provider lacks that capability; remove this method from the
Provider type so the wrapper no longer unconditionally implements
core.NativeFileProviderTypeLister, and instead add a helper on Provider such as
GetNativeFileProviderTypes (or NativeFileProviderTypesOptional) that does an
interface assertion on p.inner for core.NativeFileProviderTypeLister and returns
(types, ok) so callers can detect availability without relying on type
assertions against the wrapper itself; update call sites to use the new helper
if needed.

---

Duplicate comments:
In `@internal/aliases/provider_test.go`:
- Around line 41-44: The StreamChatCompletion implementation in providerMock
returns io.NopCloser(nil) which can panic when read is attempted; update
providerMock.StreamChatCompletion (and the other test mock at lines ~55-58) to
return a safe empty reader instead (for example wrap an empty bytes.Reader or
strings.NewReader with io.NopCloser) so the returned io.ReadCloser is non-nil
and safe to read/close during tests.

In `@internal/server/request_model_resolution.go`:
- Around line 26-30: The current logic checks only the outer provider for the
resolvedModelProvider interface and falls back to core.ParseModelSelector, which
bypasses alias-aware providers wrapped inside other types; update the resolution
in resolveRequestModel/ensureRequestModelResolution to iterate unwrap wrappers
(calling Unwrap on providers that expose it) until you find a provider that
implements resolvedModelProvider, then call its ResolveModel(model,
providerHint) and use its resolvedSelector/aliasApplied/err; only if no inner
provider implements resolvedModelProvider fall back to core.ParseModelSelector.
Ensure you reference the resolvedModelProvider interface, ResolveModel method,
Unwrap method on wrapper types, the provider variable, and
core.ParseModelSelector when making the change.