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

Inline comments:
In `@config/config_test.go`:
- Around line 268-276: The test embeds manualRulesPath directly into a
double-quoted YAML string (the yaml variable) which makes it platform-dependent
on Windows; instead construct the YAML via a Go value and yaml.Marshal (or
otherwise quote/escape the path safely) so backslashes aren't treated as YAML
escapes. Change the code that builds the yaml string (referencing
manualRulesPath and the yaml variable) to create a struct representing the
fallback config and call yaml.Marshal to produce the bytes, then write those
bytes with os.WriteFile (the same call that writes filepath.Join(dir,
"config.yaml")).

In `@config/config.go`:
- Around line 734-744: The code currently allows an empty fallback mode to pass
by normalizing it to ""—update the validation in the loop over cfg.Overrides
(working with FallbackModelOverride and normalizeFallbackMode) to reject missing
modes: after calling override.Mode = normalizeFallbackMode(override.Mode) check
if override.Mode == "" and return a config error (e.g.,
"fallback.overrides[%q].mode must be one of: auto, manual, off" or
"fallback.overrides[%q].mode cannot be empty"), otherwise continue to call
override.Mode.Valid() as before so entries like fallback.overrides.gpt-4o: {}
fail to load.

In `@config/fallback.yaml`:
- Around line 1-8: The fallback settings in config/fallback.yaml are never read
because config.Load() only reads config/config.yaml or config.yaml; update the
config loading logic (the config.Load function) to also detect and merge
config/fallback.yaml (or make loader scan for a fallback file name) and merge
its "fallback" section into the main configuration, or alternatively add a note
and copy the fallback keys into the primary config file; ensure the codepath
uses the "fallback" key from the merged config so entries like
"fallback.default_mode" and "fallback.overrides" (and specific overrides such as
"gpt-4o" / "claude-sonnet-4") are applied at runtime.

In `@internal/fallback/resolver.go`:
- Around line 387-395: sameFamily currently trims to check emptiness but
compares the original untrimmed source.Family and candidate.Family, causing
mismatches when whitespace differs; update sameFamily to trim both values into
local variables (e.g., srcFam := strings.TrimSpace(source.Family), candFam :=
strings.TrimSpace(candidate.Family)), validate those for non-empty, and then
compare srcFam == candFam so equality uses the trimmed strings.

In `@internal/responsecache/handle_request_test.go`:
- Around line 125-131: The test races with asynchronous cache writes scheduled
by run(false) because defer store.Close() can close the store before those
goroutines finish; modify the test (or run) to wait for the background
cache-population to complete before asserting: add a synchronization point
(e.g., expose and call a wait method on the fake store like
WaitForPendingWrites(), or have run(false) block until its scheduled cache write
goroutine signals completion) and then perform the checks on
rec2.Header().Get("X-Cache") and handlerCalls so defer store.Close() no longer
races with the async work.

---

Outside diff comments:
In `@internal/providers/registry.go`:
- Around line 245-251: When constructing the nameToProvider map and when loading
cached provider entries, detect entries where cachedProv.ProviderType == "" and
backfill it by calling the registry's GetProviderType() (or using
r.providerNames mapping) so the ProviderType is populated for older cache
records; update the code paths that build nameToProvider (using r.providerNames
and the nameToProvider map) and the cache-read logic to set
cachedProv.ProviderType before trusting info.ProviderType in
ListModelsWithProvider() and other consumers. Ensure the backfill happens
immediately after reading the cached provider and before inserting into
nameToProvider so subsequent calls use the filled ProviderType.

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

Inline comments:
In `@internal/fallback/resolver.go`:
- Around line 75-95: ResolveFallbacks currently builds manualSelectorsFor and
may enable autoSelectorsFor even for embedding requests; detect embedding
operations early by checking op (core.OperationEmbeddings) or computing
requiredCategoryForOperation(op) and if it equals core.CategoryEmbedding, return
nil before calling manualSelectorsFor or autoSelectorsFor so no fallback
candidates (manual or auto) are produced for embeddings; update ResolveFallbacks
to perform this early-return check and keep references to manualSelectorsFor,
autoSelectorsFor, ResolveFallbacks, requiredCategoryForOperation,
core.OperationEmbeddings and core.CategoryEmbedding to locate the change.
- Around line 298-325: In Resolver.matchKeys the generated key order puts bare
model keys before provider-qualified keys so generic entries like
fallback.overrides["gpt-4o"] shadow provider-specific entries; change the key
construction so that when source != nil and source.ProviderName != "" and
source.Model.ID != "" you insert the provider-qualified key
(source.ProviderName+"/"+source.Model.ID) before the bare keys
(resolution.Requested.Model and resolution.ResolvedSelector.Model) so
provider-qualified keys are emitted earlier; keep the same trimming/duplication
filtering logic and the existing calls resolution.RequestedQualifiedModel(),
resolution.ResolvedQualifiedModel(), resolution.Requested.Model and
resolution.ResolvedSelector.Model to locate where to reorder without altering
the duplicate removal loop.

---

Outside diff comments:
In `@internal/providers/registry.go`:
- Around line 264-279: The code currently prefers cachedProv.ProviderType over
the configured provider type, which can leave stale metadata attached to a new
provider instance; change the assignment so providerType is taken from the
configured provider (the current provider instance) rather than the cache: after
computing providerType from cachedProv, overwrite it with the provider's
configured type (use the provider's accessor such as provider.Type() or
provider.GetType()/GetProviderType() as appropriate in this codebase) so that
providerType reflects the live provider for provider, providerName, cachedProv
and nameToProviderType usage.

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

Inline comments:
In `@internal/providers/registry.go`:
- Around line 734-742: In ListModelsWithProviderByCategory(), stop
reconstructing provider metadata from r.providerTypes and the map key and
instead use the stored values on the info object: set
ModelWithProvider.ProviderType = info.ProviderType and ProviderName =
info.ProviderName (and use qualifyPublicModelID(info.ProviderName, modelID) for
Selector) so the category-filtered listing returns the same
provider_type/provider_name as ListModelsWithProvider(); update any variables
like publicProviderName and selector construction to derive from info rather
than the registry maps.

---

Duplicate comments:
In `@internal/fallback/resolver.go`:
- Around line 302-341: matchKeys currently infers provider qualification by
reparsing the rendered selector strings via
selectorHasProvider(core.ParseModelSelector), which misorders keys for bare
model IDs that contain "/" (e.g. meta-llama/Meta-Llama-3-70B). Fix by driving
ordering from explicit provider fields instead: stop using selectorHasProvider
and instead check the parsed/provider fields on the request/resolved selector
objects (e.g. resolution.Requested.Provider,
resolution.ResolvedSelector.Provider) and the resolved source
(source.ProviderName and source.Model.ID) when deciding to prepend
provider-qualified keys; ensure you still include
resolution.RequestedQualifiedModel(), resolution.ResolvedQualifiedModel(),
resolution.Requested.Model and resolution.ResolvedSelector.Model but only treat
them as provider-qualified if the corresponding explicit Provider fields are
non-empty.

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

Outside diff comments:
In `@internal/providers/registry.go`:
- Around line 157-177: The code only adds the first provider's ModelInfo to
newModels (the map passed to modeldata.Enrich), so alternate provider-specific
ModelInfo entries in newModelsByProvider remain unenriched (Metadata == nil);
change the enrichment step to include every provider-specific ModelInfo by
flattening newModelsByProvider (or iterating each provider map) and passing all
ModelInfo instances to modeldata.Enrich (or calling modeldata.Enrich per
provider map) instead of only using newModels, ensuring every ModelInfo (from
newModelsByProvider) is enriched before being kept/returned.
- Around line 264-279: LoadFromCache populates ModelInfo.ProviderType but
registryAccessor.GetProviderType and SaveToCache still derive type from
r.providerTypes[info.Provider], which can overwrite or drop the backfilled
value; update GetProviderType and SaveToCache to prefer the stored ProviderType
on the ModelInfo (or cachedProv.ProviderType) when non-empty before falling back
to r.providerTypes[info.Provider], and ensure SaveToCache writes the
ProviderType from info.ProviderType so modeldata.Enrich sees the backfilled
value as the source of truth.

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

Inline comments:
In `@config/config.go`:
- Around line 780-795: The loop building the manual map allows distinct decoded
keys that collide after strings.TrimSpace to silently overwrite each other;
update the code that iterates over decoded (the block using variables manual,
key, models, normalized) to detect if the trimmed key already exists in manual
and return a descriptive error (e.g., "duplicate manual rule key after trimming:
%q") instead of overwriting, preserving the existing behavior for empty keys and
empty model entries.
- Around line 745-761: When normalizing cfg.Overrides, detect collisions caused
by trimming keys: build a temporary set of trimmed keys and if a trimmed key
already exists (e.g., original keys like "gpt-4o" vs " gpt-4o "), return an
error instead of silently overwriting; modify the loop that currently trims keys
and assigns to normalized (referencing cfg.Overrides, normalized, and
FallbackModelOverride/override.Mode and normalizeFallbackMode) to check for
duplicates after strings.TrimSpace(key) and fail with a clear error message
indicating the duplicate trimmed key.

In `@internal/providers/registry_test.go`:
- Around line 1199-1234: The test currently asserts equality of selectors
between ListModelsWithProvider() and ListModelsWithProviderByCategory(), which
relies on implementation-derived values; change it to assert the explicit
expected selector value instead. In
TestListModelsWithProviderByCategory_UsesStoredProviderMetadata, replace the
comparison of filtered[0].Selector == allModels[0].Selector with a direct check
against the expected string (e.g., "public-openai/gpt-4o") computed from
ModelInfo.ProviderName and the model key, keeping the rest of the assertions for
ProviderName and ProviderType; this uses the same symbols:
ListModelsWithProvider, ListModelsWithProviderByCategory, and
ModelInfo.ProviderName.

In `@internal/server/fallback_test.go`:
- Around line 103-294: Add streaming equivalents of the existing fallback tests:
reproduce TestChatCompletion_FallsBackToAlternateModel and
TestResponses_FallsBackToAlternateModel but call the streaming endpoints (the
stream-handling functions: streamChatCompletion / streamResponses or their
handler methods) with stream=true in the request, assert the provider was
attempted first on the primary model then the alternate provider (check
provider.chatCalls or provider.responsesCalls length and ordering), assert the
streamed output contains the fallback content, and assert
core.GetFallbackUsed(c.Request().Context()) is set; also add a test mirroring
TestChatCompletion_DoesNotFallbackWhenExecutionPolicyDisablesFallback to ensure
the streaming fast-path bypass respects the ExecutionPolicy.Fallback=false flag
(i.e., only primary model attempted and appropriate status code returned).

In `@internal/server/translated_inference_service.go`:
- Around line 526-535: The helper providerTypeForSelector currently uses the
primary plan fallback when registry lookup returns empty, which misattributes
fallback traffic; update providerTypeForSelector to first prefer the selector's
explicit provider (e.g., call selector.Provider() or the selector field that
exposes the manually-specified provider) if non-empty, then try
s.provider.GetProviderType(selector.QualifiedModel()) and return that if
non-empty, and only finally return the incoming fallback parameter (after
trimming). Ensure you reference providerTypeForSelector,
selector.QualifiedModel(), selector.Provider() (or the selector method/field
that holds the explicit provider), and s.provider.GetProviderType(...) when
making these checks.

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

Inline comments:
In `@config/config_test.go`:
- Around line 547-555: The test currently writes the example config to
filepath.Join(dir, "config.yaml") but the documented and exercised setup expects
config/config.yaml; update the test so the example config is written to
filepath.Join(dir, "config", "config.yaml") (adjust the os.WriteFile call that
creates the exampleData) and ensure the fallback example file remains at
filepath.Join(dir, "config", "fallback.example.json"); change any corresponding
path assumptions in this test so the loader exercises the documented
config/config.yaml resolution (update the os.WriteFile and any related
filepath.Join uses in the test).

In `@config/config.example.yaml`:
- Around line 110-117: The example YAML uses unquoted fallback mode values
(e.g., default_mode: off, mode: manual) which can be parsed as booleans by some
YAML tools; update the example to quote all mode values under the fallback block
(reference keys: fallback, default_mode, overrides, and the per-model mode
entries like "gpt-4o" -> mode) so values are explicit strings and safe to
copy/paste across editors and linters.

In `@config/config.go`:
- Around line 737-770: cfg currently allows DefaultMode or any Overrides to be
set to "manual" even when ManualRulesPath is empty which leads to a resolver
with empty chains at runtime; after normalizing cfg.DefaultMode and each
override (uses normalizeFallbackMode, FallbackModeOff, FallbackModelOverride and
override.Mode.Valid()) add a validation step that if
strings.TrimSpace(cfg.ManualRulesPath) == "" and (cfg.DefaultMode ==
FallbackModeManual or any override.Mode == FallbackModeManual) then return an
error like "fallback.manual_rules_path must be set when fallback.default_mode or
any fallback.overrides[].mode is 'manual'"; only set cfg.Manual = nil and return
nil after this validation passes.

In `@internal/executionplans/types.go`:
- Around line 35-49: The plan hash differs when FeatureFlags.Fallback is omitted
because runtimeFeatures() treats nil as true but normalizePayload() hashes the
raw payload; fix by canonicalizing the fallback before hashing: add a short
canonicalization step (e.g., a FeatureFlags.Canonicalize() or adjust
normalizePayload()) that ensures FeatureFlags.Fallback is set to true when nil
and use that canonicalized FeatureFlags (or the ExecutionFeatures returned by
runtimeFeatures()) when computing plan_hash so semantically identical plans
produce the same hash; reference FeatureFlags.runtimeFeatures(),
normalizePayload(), FeatureFlags, and plan_hash when locating where to apply the
change.

In `@internal/server/fallback_test.go`:
- Around line 343-392: Add an assertion in
TestResponses_FallsBackToAlternateModel to verify that the fallback flag was
set: after calling handler.Responses(c) and checking the status, call
core.GetFallbackUsed(c.Request().Context()) and assert it is true; this mirrors
other tests (e.g., TestChatCompletion_FallsBackToAlternateModel) and ensures
dispatchResponses/markRequestFallbackUsed was invoked when falling back to the
alternate model.

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

Inline comments:
In `@config/config.example.yaml`:
- Around line 112-115: The comment for manual_rules_path is misleading about
optionality; update the example comment and/or text so it states that the JSON
file is optional only if no model override uses manual mode, and that when any
override sets overrides:"gpt-4o".mode (or any overrides.*.mode) to "manual" a
valid manual_rules_path must be provided; change the inline note next to
manual_rules_path to clearly state this requirement and/or add a brief sentence
under overrides indicating that manual mode requires a rules file.

In `@config/config.go`:
- Around line 788-810: The current json.Unmarshal into variable decoded loses
earlier duplicate JSON keys; before unmarshalling, use a json.Decoder to stream
the top-level object from expandString(string(raw)) and detect duplicate raw
keys so you can reject the file early. Concretely: create a json.Decoder over
strings.NewReader(expandString(string(raw))), require the first token is '{',
iterate by reading each key token (as string), check a seenKeys
map[string]struct{} for duplicates and return an error if a key repeats (before
trimming), then decode the corresponding value into a temporary []string (or raw
json.RawMessage then unmarshal) and populate the existing decoded/manual logic
(retain trimming and duplicate-after-trim checks) using the same identifiers
decoded, manual, raw, path so the rest of the function can remain unchanged.

---

Duplicate comments:
In `@internal/server/fallback_test.go`:
- Around line 389-394: The test currently only checks responsesCalls and
core.GetFallbackUsed but should also verify the fallback selector order and the
actual payload returned for the non-stream Responses path: after the call,
assert that the provider recorded the selector invocation sequence (e.g., check
provider.requestedSelectors or provider.selectorCalls contains the expected
primary-then-fallback order), and assert the HTTP response body/parsed Responses
payload equals the expected fallback payload (and optionally
content-type/status) to ensure the fallback return is correct; update the
assertions around provider.responsesCalls and
core.GetFallbackUsed(c.Request().Context()) to also validate the selector call
sequence and the exact returned payload.

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

Inline comments:
In `@config/config.go`:
- Around line 817-821: Decoding into a []string accepts JSON null and yields a
nil slice, which silently disables the rule; in the fallback.manual_rules_path
parsing (where decoder.Decode(&models) is called and result assigned to
decoded[key]) explicitly reject null by first decoding into an interface{} or
using decoder.Token/RawMessage to detect a JSON null, and if null return a
fmt.Errorf indicating "fallback.manual_rules_path: null not allowed for %q"
(including path); only after confirming the value is a JSON array decode/convert
it into []string and assign to decoded[key].

In `@internal/server/fallback_test.go`:
- Around line 411-453: Add two negative tests for the Responses endpoint
mirroring existing ChatCompletion tests: create
TestResponses_DoesNotFallbackOnNonAvailabilityError and
TestResponses_DoesNotFallbackWhenExecutionPolicyDisablesFallback that follow the
pattern of TestResponses_StreamFallsBackToAlternateModel; use the same
fallbackProvider/test handler setup but configure responsesErrors to return a
non-availability error (not core.NewNotFoundError) for the primary model in the
first test and assert that the handler does not attempt the alternate model and
that fallback is not marked in context, and in the second test configure the
execution policy to disable fallback (use the fallbackResolverStub or policy
stub used elsewhere) and assert no fallback attempt and no fallback-used context
flag; reference handler.Responses, fallbackProvider, fallbackResolverStub and
core.GetFallbackUsed to locate and structure the tests.