feat(#92): IMP-92 u1~u5 AI fallback config validation (model ping + operational error classification)

Replaces #84 UI-noise removal plan with positive operational-alert contract.
Five-axis stack lands together: (1) default model literal moved to current
Opus-family ID, (2) Anthropic SDK error classifier mapping exceptions to
quota/billing/auth/other, (3) api_error_kind plumbed through ai_repair_status
summary + per-record retention, (4) Step 0 preflight ping gated under
ai_fallback_enabled (default OFF preserved) with fail-fast on invalid
model/key, (5) frontend formatter rewritten to surface only operational
quota/billing/auth toasts (non-operational paths return null per
feedback_auto_pipeline_first silent-pipeline policy).

u1 - default model literal claude-opus-4-6-20250415 -> claude-opus-4-7
     (src/config.py + tests/test_phase_z2_ai_fallback_config.py lock mirror)
u2 - classify_operational_error type+status_code dispatch + Step 12
     api_error_kind stamp on except path (src/phase_z2_ai_fallback/client.py
     + src/phase_z2_ai_fallback/step12.py + tests/phase_z2_ai_fallback/test_step12.py)
u3 - _summarize_ai_repair_status aggregates api_error_kinds {quota,billing,
     auth,other}; error_records[i].api_error_kind retained per-record
     (src/phase_z2_pipeline.py + tests/test_imp47b_failure_surface.py)
u4 - _run_step0_ai_preflight + Step0PreflightError; preflight only fires
     when ai_fallback_enabled=true; one-token ping; invalid key/model =>
     setup failure before Step 1 (src/phase_z2_pipeline.py +
     tests/phase_z2/test_pipeline_step0_preflight.py NEW)
u5 - AiRepairStatus.api_error_kinds? interface + formatAiRepairHumanReview
     Message rewritten: operational quota/billing/auth -> Korean copy
     verbatim from issue body (tie-break quota -> billing -> auth);
     validation/coverage_violated/unsupported_kind/generic-other/legacy
     payload -> null (Front/client/src/services/designAgentApi.ts +
     Front/client/tests/imp47b_human_review_toast.test.tsx)

Guardrails respected:
- feedback_demo_env_toggle_policy: default OFF preserved; preflight skipped
  when ai_fallback_enabled=false (test_preflight_skipped_when_disabled
  asserts anthropic.Anthropic() not called).
- feedback_auto_pipeline_first: non-operational AI failures stay silent;
  only quota/billing/auth reach user toast.
- feedback_ai_isolation_contract: AI remains fallback-only; no normal-path
  migration; MDX preserved.
- project_imp46_carveout_caveat: cache_key/fingerprints fields untouched on
  every record; no overlap with #62 cache region.
- feedback_no_hardcoding: zero MDX-sample-specific literals; classifier
  dispatch by SDK type, not by string parsing.
- feedback_artifact_status_naming: operational toast scoped to alert axis,
  not overall PASS signal.

Tests:
- Targeted u1+u2+u3+u4: 63 passed
- u5 vitest (Front/): 10/10 passed
- tests/phase_z2_ai_fallback dir regression: 240 passed
- tests/phase_z2 dir regression: 323 passed
- IMP-92-adjacent (-k "imp47b or ai_fallback or preflight or step12 or step0"): 299 passed (808 deselected)
- u1 baseline lock (test_client_mock.py): 8 passed
Zero failures, zero regressions outside scope.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

src/phase_z2_ai_fallback/client.py

@@ -31,6 +31,55 @@ _TRANSIENT_ERRORS: tuple[type[BaseException], ...] = (
 # Output cap is an Anthropic API requirement, not a policy knob (u1).
 _MAX_OUTPUT_TOKENS = 4096
 
+# IMP-92 u2 — Anthropic SDK exception → operational error kind classifier.
+# Stamped onto Step 12 AI repair records (api_error_kind) so the frontend
+# operational alert formatter can surface quota / billing / auth to users
+# while keeping non-operational ("other") failures silent. The classifier
+# is type-based (not string parsing) and the four kinds are the only
+# values frontend operational formatter is allowed to render.
+_OPERATIONAL_ERROR_KIND_QUOTA = "quota"
+_OPERATIONAL_ERROR_KIND_BILLING = "billing"
+_OPERATIONAL_ERROR_KIND_AUTH = "auth"
+_OPERATIONAL_ERROR_KIND_OTHER = "other"
+
+
+def classify_operational_error(exc: BaseException) -> str:
+    """Return the operational error kind for an Anthropic SDK exception.
+
+    Dispatch combines SDK exception type with the HTTP status code so the
+    issue body's explicit operational contract (429 quota / 402 billing /
+    401 auth) is honoured even when the SDK surfaces a 402 as the generic
+    ``anthropic.APIStatusError`` rather than a typed subclass:
+
+      * ``anthropic.RateLimitError`` OR HTTP 429        → ``"quota"``
+      * ``anthropic.PermissionDeniedError`` OR HTTP 402 → ``"billing"``
+        (Anthropic Payment Required surfaces as 402; PermissionDenied/403
+        is the SDK-typed billing/permission surface)
+      * ``anthropic.AuthenticationError`` OR HTTP 401   → ``"auth"``
+      * everything else                                 → ``"other"`` (silent on UI)
+
+    The frontend formatter renders quota / billing / auth and returns
+    ``None`` for ``"other"`` so non-operational AI failures stay silent
+    per the #84 replacement-plan contract.
+    """
+    if isinstance(exc, anthropic.RateLimitError):
+        return _OPERATIONAL_ERROR_KIND_QUOTA
+    if isinstance(exc, anthropic.PermissionDeniedError):
+        return _OPERATIONAL_ERROR_KIND_BILLING
+    if isinstance(exc, anthropic.AuthenticationError):
+        return _OPERATIONAL_ERROR_KIND_AUTH
+    if isinstance(exc, anthropic.APIStatusError):
+        status_code = getattr(exc, "status_code", None)
+        if status_code is None:
+            status_code = getattr(getattr(exc, "response", None), "status_code", None)
+        if status_code == 429:
+            return _OPERATIONAL_ERROR_KIND_QUOTA
+        if status_code == 402:
+            return _OPERATIONAL_ERROR_KIND_BILLING
+        if status_code == 401:
+            return _OPERATIONAL_ERROR_KIND_AUTH
+    return _OPERATIONAL_ERROR_KIND_OTHER
+
 
 class AiFallbackBudgetExceeded(RuntimeError):
     """Per-run AI call budget (u1 ai_fallback_budget_per_run) exhausted."""

src/phase_z2_ai_fallback/step12.py

@@ -56,6 +56,7 @@ import hashlib
 import json
 from typing import Any, Callable, Iterable
 
+from src.phase_z2_ai_fallback.client import classify_operational_error
 from src.phase_z2_ai_fallback.router import route_ai_fallback
 from src.phase_z2_ai_fallback.signature import bucket_char_count, build_signature
 
@@ -96,6 +97,7 @@ def gather_step12_ai_repair_proposals(
           "skip_reason": str | None,
           "proposal": dict | None,
           "error": str | None,
+          "api_error_kind": str | None,   # IMP-92 u2 (quota|billing|auth|other)
           "cache_key": str | None,        # IMP-46 u4
           "fingerprints": dict | None,    # IMP-46 u4
         }
@@ -130,6 +132,7 @@ def gather_step12_ai_repair_proposals(
             "skip_reason": None,
             "proposal": None,
             "error": None,
+            "api_error_kind": None,
             "cache_key": None,
             "fingerprints": None,
         }
@@ -205,6 +208,7 @@ def gather_step12_ai_repair_proposals(
         except Exception as exc:  # noqa: BLE001 — record + continue, no AI re-raise
             record["ai_called"] = True
             record["error"] = f"{type(exc).__name__}: {exc}"
+            record["api_error_kind"] = classify_operational_error(exc)
             records.append(record)
             continue
         if proposal is None: