A2 Adaptive Completion Core + Provider-Neutral Model Gateway

config.py

@@ -1,5 +1,30 @@
 # -*- coding: utf-8 -*-
 import os
+import json
+
+def _provider_fallbacks(env_name):
+    return [part.strip().lower() for part in str(os.environ.get(env_name, "") or "").split(",") if part.strip()]
+
+def _optional_plan_range(prefix):
+    raw_min = str(os.environ.get(f"{prefix}_WORD_MIN", "") or "").strip()
+    raw_max = str(os.environ.get(f"{prefix}_WORD_MAX", "") or "").strip()
+    if not raw_min or not raw_max:
+        return None
+    try:
+        lo, hi = int(raw_min), int(raw_max)
+    except ValueError:
+        return None
+    return [min(lo, hi), max(lo, hi)]
+
+def _plan_model_routes(prefix):
+    raw = str(os.environ.get(f"{prefix}_MODEL_ROUTES_JSON", "") or "").strip()
+    if not raw:
+        return {}
+    try:
+        parsed = json.loads(raw)
+    except Exception:
+        return {}
+    return dict(parsed) if isinstance(parsed, dict) else {}
 
 def load_config():
     base_config = {
@@ -117,6 +142,62 @@ def load_config():
             "DEEPSEEK_SHOW_REASONING",
             "false",
         ).strip().lower() in {"1", "true", "yes", "on"},
+        # A2: provider-neutral routing seam.  Academic code requests capabilities;
+        # this table decides which provider adapter owns each capability.  The
+        # current verified production route remains DeepSeek until a trusted plan
+        # policy explicitly selects another registered provider.
+        "model_gateway": {
+            "default_provider": os.environ.get("MODEL_PROVIDER_DEFAULT", "deepseek").strip().lower(),
+            "capability_routes": {
+                "reasoning": {"provider": os.environ.get("MODEL_PROVIDER_REASONING", "deepseek"), "provider_role": "reasoning", "fallback_providers": _provider_fallbacks("MODEL_PROVIDER_REASONING_FALLBACKS")},
+                "writing": {"provider": os.environ.get("MODEL_PROVIDER_WRITING", "deepseek"), "provider_role": "writing", "fallback_providers": _provider_fallbacks("MODEL_PROVIDER_WRITING_FALLBACKS")},
+                "translation": {"provider": os.environ.get("MODEL_PROVIDER_TRANSLATION", "deepseek"), "provider_role": "translation", "fallback_providers": _provider_fallbacks("MODEL_PROVIDER_TRANSLATION_FALLBACKS")},
+                "fast": {"provider": os.environ.get("MODEL_PROVIDER_FAST", "deepseek"), "provider_role": "fast", "fallback_providers": _provider_fallbacks("MODEL_PROVIDER_FAST_FALLBACKS")},
+                "repair": {"provider": os.environ.get("MODEL_PROVIDER_REPAIR", os.environ.get("MODEL_PROVIDER_REASONING", "deepseek")), "provider_role": "reasoning", "fallback_providers": _provider_fallbacks("MODEL_PROVIDER_REPAIR_FALLBACKS")},
+                "final_review": {"provider": os.environ.get("MODEL_PROVIDER_FINAL_REVIEW", os.environ.get("MODEL_PROVIDER_REASONING", "deepseek")), "provider_role": "reasoning", "fallback_providers": _provider_fallbacks("MODEL_PROVIDER_FINAL_REVIEW_FALLBACKS")},
+            },
+        },
+        # A2: content problems are recoverable by default.  These budgets are
+        # model-policy inputs, not hard-coded academic business rules.
+        "adaptive_completion": {
+            "enabled": os.environ.get("ADAPTIVE_COMPLETION_ENABLED", "true").strip().lower() in {"1", "true", "yes", "on"},
+            "section_repair_passes": max(1, min(4, int(os.environ.get("ADAPTIVE_SECTION_REPAIR_PASSES", "2")))),
+            "front_matter_repair_passes": max(1, min(4, int(os.environ.get("ADAPTIVE_FRONT_MATTER_REPAIR_PASSES", "2")))),
+            "translation_fallback_passes": max(1, min(3, int(os.environ.get("ADAPTIVE_TRANSLATION_FALLBACK_PASSES", "1")))),
+        },
+        # A2 only freezes a policy interface.  Worker/D1 payment and quota logic
+        # is intentionally unchanged.  Concrete prices/entitlements remain
+        # backend-owned and can be revised without changing manuscript code.
+        "plan_policy_version": "plan-policy-v1",
+        "plan_policies": {
+            "legacy_current": {
+                "word_range": [5000, 20000],
+                "paper_limit": None,
+                "model_routes": {},
+                "repair_profile": "standard",
+            },
+            # A2 deliberately does not invent commercial tier limits. Concrete
+            # word ranges and provider routes are deployment policy, supplied by
+            # environment/backend configuration when those products are enabled.
+            "free": {
+                "word_range": _optional_plan_range("SMARTPAPER_PLAN_FREE"),
+                "paper_limit": None,
+                "model_routes": _plan_model_routes("SMARTPAPER_PLAN_FREE"),
+                "repair_profile": os.environ.get("SMARTPAPER_PLAN_FREE_REPAIR_PROFILE", "economy"),
+            },
+            "standard": {
+                "word_range": _optional_plan_range("SMARTPAPER_PLAN_STANDARD"),
+                "paper_limit": None,
+                "model_routes": _plan_model_routes("SMARTPAPER_PLAN_STANDARD"),
+                "repair_profile": os.environ.get("SMARTPAPER_PLAN_STANDARD_REPAIR_PROFILE", "standard"),
+            },
+            "flagship": {
+                "word_range": _optional_plan_range("SMARTPAPER_PLAN_FLAGSHIP"),
+                "paper_limit": None,
+                "model_routes": _plan_model_routes("SMARTPAPER_PLAN_FLAGSHIP"),
+                "repair_profile": os.environ.get("SMARTPAPER_PLAN_FLAGSHIP_REPAIR_PROFILE", "maximum"),
+            },
+        },
         # Citation-semantic audit repairs only affected sentences. Technical
         # failures fall back to deterministic single-source recovery and are
         # recorded in the audit log instead of terminating the whole paper.

core/generation_runner.py

@@ -26,6 +26,7 @@ from typing import Callable, Any
 from config import APP_CONFIG, AMJ_PROMPTS, ASQ_PROMPTS
 from core.checkpoint_store import TaskCheckpointStore
 from core.meta_extractor import extract_golden_metadata
+from core.model_gateway import resolve_plan_policy_snapshot
 from core.pipeline_agent import SSciPipelineAgent, PipelineCancelledError
 from core.production_guard import build_validated_package, replace_abstract
 from core.qualitative_engine import get_qualitative_engine
@@ -1206,6 +1207,122 @@ class GenerationRunner:
                 continue
             quality_notes.append(note)
 
+    @staticmethod
+    def _record_adaptive_completion_residual(quality_notes: list, rows, *, section_name: str, stage: str) -> None:
+        kinds = sorted({str((row or {}).get("type") or "validation_issue") for row in list(rows or []) if isinstance(row, dict)})
+        note = {
+            "type": "adaptive_completion_residual",
+            "severity": "ADVISORY",
+            "section": str(section_name or "Manuscript"),
+            "issue_type": ",".join(kinds[:8]) or "validation_issue",
+            "detail": (
+                "SmartPaper completed the manuscript after bounded adaptive repair. "
+                "A conservative validator still reported a residual issue, so it is recorded for optional author review instead of terminating generation."
+            ),
+            "user_action": "Review this passage before formal submission if additional refinement is desired.",
+            "stage": str(stage or "adaptive_completion"),
+        }
+        sig = (note["section"], note["issue_type"], note["stage"])
+        if not any(
+            (str(x.get("section") or ""), str(x.get("issue_type") or ""), str(x.get("stage") or "")) == sig
+            for x in quality_notes if isinstance(x, dict)
+        ):
+            quality_notes.append(note)
+
+    def _adaptive_repair_section_after_exhaustion(
+        self, *, agent, quant_engine, text: str, violations, mode: str, section_id: str,
+        section_name: str, data_metadata: dict, study_evidence: str, evidence_contract: str,
+        hypothesis_ledger: dict, task: dict, quote_invocation_plan: dict, quality_notes: list,
+    ):
+        """A2 last-mile semantic repair after lineage retry exhaustion.
+
+        Content defects are recoverable by default.  The model gets the locked
+        study/evidence context, then deterministic validators re-check the exact
+        returned unit.  If conservative diagnostics still disagree after bounded
+        repair, the best complete unit is retained and the residual is recorded
+        in Appendix quality notes rather than killing the whole paper.
+        """
+        current = str(text or '').strip()
+        remaining = list(violations or [])
+        passes = max(1, int((APP_CONFIG.get("adaptive_completion") or {}).get("section_repair_passes", 2)))
+        scopes = ("paragraph", "section", "section")
+        for idx in range(passes):
+            self._check_cancelled()
+            repaired = agent.adaptive_repair_academic_unit(
+                current, violations=remaining, section_id=section_id, section_name=section_name,
+                mode=mode, study_evidence=study_evidence, evidence_contract=evidence_contract,
+                repair_scope=scopes[min(idx, len(scopes) - 1)],
+            )
+            if not str(repaired or '').strip():
+                repaired = current
+            if mode == "amj" and hypothesis_ledger:
+                repaired = self._normalize_hypothesis_ordinal_aliases(repaired, hypothesis_ledger)
+            if mode == "asq" and str(section_id or '').lower() == "findings":
+                repaired = self._strip_model_controlled_qualitative_quotes(repaired, data_metadata)
+                repaired = self._render_planned_qualitative_quotes(
+                    repaired, task=task, data_metadata=data_metadata, quote_invocation_plan=quote_invocation_plan,
+                )
+            if mode == "amj" and data_metadata.get("quantitative_table_manifest"):
+                if str(section_id or '').lower() == "results":
+                    repaired = self._apply_quantitative_table_contract(repaired, data_metadata, section_name)
+                else:
+                    repaired = self._strip_model_markdown_tables(repaired)
+            repaired, _enum_rows = agent.repair_and_validate_enumeration_contract(
+                repaired, section_name=section_name
+            )
+            rows = self._section_validation_bundle(
+                mode, agent, quant_engine, repaired, data_metadata, section_id=section_id,
+                section_name=section_name, evidence_contract=evidence_contract, include_critic=False,
+                hypothesis_ledger=hypothesis_ledger,
+            )
+            blocking, advisory = self._partition_section_violations(
+                rows, section_name=section_name, mode=mode, exhausted=True
+            )
+            if advisory:
+                self._record_section_advisories(quality_notes, advisory, section_name=section_name)
+            current = repaired
+            remaining = blocking
+            if not blocking:
+                return current, []
+        if remaining:
+            self._record_adaptive_completion_residual(
+                quality_notes, remaining, section_name=section_name, stage="section_repair_exhausted"
+            )
+        return current, remaining
+
+    def _adaptive_repair_front_matter(
+        self, *, agent, quant_engine, abstract_text: str, violations, mode: str,
+        data_metadata: dict, study_evidence: str, hypothesis_ledger: dict, quality_notes: list,
+        label: str,
+    ):
+        current = str(abstract_text or '').strip()
+        remaining = list(violations or [])
+        passes = max(1, int((APP_CONFIG.get("adaptive_completion") or {}).get("front_matter_repair_passes", 2)))
+        for idx in range(passes):
+            repaired = agent.adaptive_repair_academic_unit(
+                current, violations=remaining, section_id="abstract", section_name=label, mode=mode,
+                study_evidence=study_evidence, evidence_contract="",
+                repair_scope="paragraph" if idx == 0 else "section",
+            )
+            repaired = str(repaired or current).strip()
+            if hypothesis_ledger:
+                repaired = self._normalize_hypothesis_ordinal_aliases(repaired, hypothesis_ledger)
+            rows = self._study_fact_violations(
+                mode, agent, quant_engine, repaired, data_metadata, section_name=label
+            )
+            if hypothesis_ledger:
+                rows.extend(self._hypothesis_contract_violations(
+                    repaired, hypothesis_ledger, section_name=label
+                ))
+            current, remaining = repaired, rows
+            if not remaining:
+                return current, []
+        if remaining:
+            self._record_adaptive_completion_residual(
+                quality_notes, remaining, section_name=label, stage="front_matter_repair_exhausted"
+            )
+        return current, remaining
+
     @staticmethod
     def _citation_violation_tags(rows) -> set:
         """Extract only citation tags owned by the rejected claim sentence.
@@ -2700,10 +2817,12 @@ class GenerationRunner:
         if not APP_CONFIG["target_words_min"] <= target_words <= APP_CONFIG["target_words_max"]:
             raise RuntimeError("target_words_out_of_range")
 
+        # A2: provider credentials are adapter-owned. DeepSeek remains the
+        # current default adapter, but the runner no longer hard-codes it as the
+        # only legal model provider.
         ds_key = str(os.environ.get("DEEPSEEK_API_KEY") or "").strip()
         s2_key = str(os.environ.get("S2_API_KEY") or "").strip()
-        if not ds_key:
-            raise RuntimeError("DEEPSEEK_API_KEY_missing")
+        plan_policy_snapshot = resolve_plan_policy_snapshot(APP_CONFIG, req)
 
         if mode == "amj":
             APP_CONFIG.update(AMJ_PROMPTS)
@@ -2712,6 +2831,7 @@ class GenerationRunner:
 
         agent = SSciPipelineAgent(ds_key, s2_key)
         self.agent = agent
+        agent.set_model_policy_snapshot(plan_policy_snapshot)
         agent.set_cancel_checker(self.cancel_checker)
         # DeepSeek/search activity marks the executor as genuinely alive; the
         # heartbeat thread decides separately when to renew D1's lease.
@@ -2729,6 +2849,7 @@ class GenerationRunner:
             state = self.checkpoints.load_confirmed() or {}
         quality_diagnostics = list(state.get("quality_diagnostics") or [])
         quality_notes = list(state.get("quality_notes") or [])
+        state.setdefault("plan_policy_snapshot", copy.deepcopy(plan_policy_snapshot))
         self._evidence_coverage_events = list(state.get("evidence_coverage_events") or [])
         if str(state.get("evidence_status") or "") == "limited":
             self._preview_evidence_status = "limited"
@@ -3006,7 +3127,14 @@ class GenerationRunner:
                         working_abstract, hypothesis_ledger, section_name="Working Abstract"
                     ))
                 if remaining_front_rows:
-                    raise RuntimeError(f"working_front_matter_study_fact_invalid_after_retry:{remaining_front_rows[:3]}")
+                    working_abstract, residual_front_rows = self._adaptive_repair_front_matter(
+                        agent=agent, quant_engine=quant_engine, abstract_text=working_abstract,
+                        violations=remaining_front_rows, mode=mode, data_metadata=data_metadata,
+                        study_evidence=planning_data_md, hypothesis_ledger=hypothesis_ledger,
+                        quality_notes=quality_notes, label="Working Abstract",
+                    )
+                    if residual_front_rows:
+                        logging.warning("Adaptive Working Abstract accepted with residual diagnostics | count=%s", len(residual_front_rows))
                 quality_diagnostics.append({
                     "scope":"working_abstract_study_fact_integrity", "name":"Working Abstract",
                     "status":"section_retry_resolved", "count":len(front_fact_rows), "examples":front_fact_rows[:3],
@@ -3311,7 +3439,14 @@ class GenerationRunner:
                         candidate_abstract, hypothesis_ledger, section_name="Working Abstract"
                     ))
                 if remaining:
-                    raise RuntimeError(f"working_front_matter_study_fact_invalid_after_retry:{remaining[:3]}")
+                    candidate_abstract, residual_front_rows = self._adaptive_repair_front_matter(
+                        agent=agent, quant_engine=quant_engine, abstract_text=candidate_abstract,
+                        violations=remaining, mode=mode, data_metadata=data_metadata,
+                        study_evidence=planning_data_md, hypothesis_ledger=hypothesis_ledger,
+                        quality_notes=quality_notes, label="Working Abstract",
+                    )
+                    if residual_front_rows:
+                        logging.warning("Adaptive resumed Working Abstract accepted with residual diagnostics | count=%s", len(residual_front_rows))
                 working_abstract = candidate_abstract
                 working_keywords = candidate_keywords or working_keywords
                 state["working_abstract"] = working_abstract
@@ -3431,6 +3566,8 @@ class GenerationRunner:
         # English writer.  A dedicated single translation agent/worker keeps
         # glossary order deterministic and avoids sharing mutable writer state.
         translation_agent = SSciPipelineAgent(ds_key, s2_key)
+        translation_agent.set_model_policy_snapshot(plan_policy_snapshot)
+        self.translation_agent = translation_agent
         translation_agent.set_execution_progress_hook(lambda: self._progress_activity())
         translation_agent.set_cancel_checker(lambda: self.cancel_checker())
         seeded_glossary = translation_agent.seed_canonical_concept_glossary(
@@ -3546,7 +3683,14 @@ class GenerationRunner:
                         working_abstract, hypothesis_ledger, section_name="Working Abstract"
                     ))
                 if remaining:
-                    raise RuntimeError(f"working_front_matter_study_fact_invalid_after_retry:{remaining[:3]}")
+                    working_abstract, residual_front_rows = self._adaptive_repair_front_matter(
+                        agent=agent, quant_engine=quant_engine, abstract_text=working_abstract,
+                        violations=remaining, mode=mode, data_metadata=data_metadata,
+                        study_evidence=planning_data_md, hypothesis_ledger=hypothesis_ledger,
+                        quality_notes=quality_notes, label="Working Abstract",
+                    )
+                    if residual_front_rows:
+                        logging.warning("Adaptive migrated Working Abstract accepted with residual diagnostics | count=%s", len(residual_front_rows))
                 quality_diagnostics.append({
                     "scope":"working_abstract_study_fact_integrity", "name":"Working Abstract",
                     "status":"section_retry_resolved", "count":len(front_fact_rows), "examples":front_fact_rows[:3],
@@ -3902,10 +4046,10 @@ Output only final academic prose. Do not report the word count."""
                 isinstance(prior_retry_exhausted, dict)
                 and str(prior_retry_exhausted.get("section_name") or "") == display_name
             ):
-                # S0-R1 deliberately does not invent an executor/network retry state.
-                # A content-invalid Section that exhausted its one local retry remains
-                # durable and fail-closed until a separately approved lifecycle change.
-                raise RuntimeError(f"section_retry_exhausted_requires_new_lifecycle:{display_name}")
+                # A2: content exhaustion is resumable.  The checkpoint records the
+                # diagnostics, but it no longer creates a terminal lifecycle state.
+                logging.warning("Adaptive completion resumed exhausted section | unit=%s", display_name)
+                state.pop("section_retry_exhausted", None)
 
             deterministic_appendix = mode == "asq" and section_id == "appendix"
             # R4: one initial attempt plus bounded lineage-owned repair turns.
@@ -4124,31 +4268,37 @@ The previous attempt for this same manuscript unit was rejected by validation. R
                             sorted({str(row.get("type") or "") for row in advisory_rows if isinstance(row, dict)}),
                         )
                     if blocking_rows:
-                        self._restore_section_citation_state(
-                            agent, citation_plan, display_name, frozen_citation_state
+                        # A2: phase-1 exhaustion escalates to a provider-neutral
+                        # semantic repair rather than terminating the manuscript.
+                        adaptive_raw = agent.adaptive_repair_academic_unit(
+                            attempt_section_text, violations=blocking_rows, section_id=section_id,
+                            section_name=display_name, mode=mode, study_evidence=writer_scoped_data_md,
+                            evidence_contract=evidence_packet, repair_scope="section",
                         )
-                        state.update({
-                            "citation_plan": citation_plan,
-                            "agent_state": agent.export_state(),
-                            "quality_diagnostics": quality_diagnostics,
-                            "quality_notes": quality_notes,
-                        })
-                        self._checkpoint_section_retry_exhausted(
-                            state, section_id=section_id, section_name=display_name,
-                            violations=blocking_rows, pct=pct, attempts=max_section_attempts,
+                        adaptive_resolved = agent.audit_and_resolve_citations(
+                            adaptive_raw, section_name=display_name, section_id=section_id,
+                            quarantine=is_quarantined, allowed_tags=allowed_section_citation_tags,
                         )
-                        blocking_citation_rows = [
-                            row for row in blocking_rows
-                            if isinstance(row, dict) and str(row.get("type") or "").startswith("citation_")
-                        ]
-                        terminal_kind = (
-                            "section_citation_invalid_after_retry"
-                            if blocking_citation_rows and len(blocking_citation_rows) == len(blocking_rows)
-                            else "section_content_invalid_after_retry"
+                        adaptive_citation_rows = copy.deepcopy(
+                            list(getattr(agent, "_last_citation_semantic_violations", []) or [])
                         )
-                        raise RuntimeError(
-                            f"{terminal_kind}:{display_name}:{blocking_rows[:3]}"
+                        adaptive_rows = self._section_validation_bundle(
+                            mode, agent, quant_engine, adaptive_raw, data_metadata,
+                            section_id=section_id, section_name=display_name,
+                            evidence_contract=evidence_packet, include_critic=False,
+                            citation_violations=adaptive_citation_rows, hypothesis_ledger=hypothesis_ledger,
                         )
+                        adaptive_blocking, adaptive_advisory = self._partition_section_violations(
+                            adaptive_rows, section_name=display_name, mode=mode, exhausted=True
+                        )
+                        if adaptive_advisory:
+                            self._record_section_advisories(quality_notes, adaptive_advisory, section_name=display_name)
+                        if adaptive_blocking:
+                            self._record_adaptive_completion_residual(
+                                quality_notes, adaptive_blocking, section_name=display_name, stage="phase1_semantic_repair"
+                            )
+                        en_resolved = adaptive_resolved
+                        state.pop("section_retry_exhausted", None)
 
                 used_after = set(agent.used_citations)
                 survived = used_after - used_before
@@ -4316,22 +4466,19 @@ The previous attempt for this same manuscript unit was rejected by validation. R
                             sorted({str(row.get("type") or "") for row in advisory_rows if isinstance(row, dict)}),
                         )
                     if blocking_rows:
-                        self._restore_section_citation_state(
-                            agent, citation_plan, display_name, frozen_citation_state
+                        en_resolved, residual_rows = self._adaptive_repair_section_after_exhaustion(
+                            agent=agent, quant_engine=quant_engine, text=en_resolved,
+                            violations=blocking_rows, mode=mode, section_id=section_id,
+                            section_name=display_name, data_metadata=data_metadata,
+                            study_evidence=writer_scoped_data_md, evidence_contract=evidence_packet,
+                            hypothesis_ledger=hypothesis_ledger, task=sec,
+                            quote_invocation_plan=quote_invocation_plan, quality_notes=quality_notes,
                         )
-                        state.update({
-                            "citation_plan": citation_plan,
-                            "agent_state": agent.export_state(),
-                            "quality_diagnostics": quality_diagnostics,
-                            "quality_notes": quality_notes,
-                        })
-                        self._checkpoint_section_retry_exhausted(
-                            state, section_id=section_id, section_name=display_name,
-                            violations=blocking_rows, pct=pct, attempts=max_section_attempts,
-                        )
-                        raise RuntimeError(
-                            f"section_content_invalid_after_retry:{display_name}:{blocking_rows[:3]}"
+                        logging.warning(
+                            "Adaptive completion accepted section | unit=%s residual=%s",
+                            display_name, len(residual_rows),
                         )
+                        state.pop("section_retry_exhausted", None)
 
                 quality_diagnostics.extend(attempt_diagnostics)
                 assigned_tag_list = list(attempt_assigned_tag_list)
@@ -4498,48 +4645,57 @@ The previous attempt for this same manuscript unit was rejected by validation. R
                     raise RuntimeError(f"final_english_section_missing:{section_title}")
                 seal = dict(section_integrity_seals.get(section_key) or {})
                 self._validate_section_integrity_seal(seal, sealed_section, section_title)
+                final_fact_rows = self._study_fact_violations(
+                    mode, agent, quant_engine, sealed_section, data_metadata, section_name=section_title
+                )
+                if final_fact_rows:
+                    self._record_adaptive_completion_residual(
+                        quality_notes, final_fact_rows, section_name=section_title, stage="final_sealed_fact_review"
+                    )
+                # A2: final validators diagnose residual content; they do not
+                # destroy an otherwise complete manuscript after adaptive repair.
                 try:
-                    if mode == "asq":
-                        agent.validate_qualitative_study_fact_contract(
-                            sealed_section, data_metadata, section_name=section_title
-                        )
-                    elif mode == "amj":
-                        quant_engine.validate_quantitative_study_fact_contract(
-                            sealed_section, data_metadata, section_name=section_title
-                        )
+                    agent.validate_enumeration_contract(
+                        sealed_section, section_name=f"Final sealed section: {section_title}"
+                    )
                 except Exception as exc:
-                    prefix = (
-                        "final_qualitative_study_fact_contract_failed"
-                        if mode == "asq" else "final_quantitative_study_fact_contract_failed"
+                    self._record_adaptive_completion_residual(
+                        quality_notes, [{"type":"enumeration_contract_invalid","reason":str(exc)[:400]}],
+                        section_name=section_title, stage="final_enumeration_review"
                     )
-                    raise RuntimeError(f"{prefix}:{section_title}") from exc
-                # Post-seal structural validation is pure validation.  Never
-                # invoke a mutating enumeration repair on frozen English text.
-                agent.validate_enumeration_contract(
-                    sealed_section, section_name=f"Final sealed section: {section_title}"
-                )
                 internal_rows = self._author_facing_internal_workflow_violations(sealed_section)
                 if internal_rows:
-                    raise RuntimeError(
-                        f"final_author_facing_purity_failed:{section_title}:{internal_rows[:3]}"
+                    self._record_adaptive_completion_residual(
+                        quality_notes, internal_rows, section_name=section_title, stage="final_reader_facing_review"
                     )
             if mode == "amj" and hypothesis_ledger:
                 hypothesis_rows = self._hypothesis_contract_violations(
                     full_draft_en, hypothesis_ledger, section_name="Full Manuscript", require_all=True
                 )
                 if hypothesis_rows:
-                    raise RuntimeError(f"final_hypothesis_contract_failed:{hypothesis_rows[:3]}")
+                    self._record_adaptive_completion_residual(
+                        quality_notes, hypothesis_rows, section_name="Full Manuscript", stage="final_hypothesis_review"
+                    )
             # Validate the completed body while the Working Abstract is still in
             # place. Final front matter must not be generated until all body
             # sections, citation cleanup, and any Discussion rebalance are frozen.
             agent.validate_manuscript_structure(full_draft_en, adaptive_structure, translated=False)
             if mode == "asq":
-                self._validate_qualitative_quote_rendering(
-                    full_draft_en, quote_invocation_plan, data_metadata
-                )
+                try:
+                    self._validate_qualitative_quote_rendering(
+                        full_draft_en, quote_invocation_plan, data_metadata
+                    )
+                except Exception as exc:
+                    self._record_adaptive_completion_residual(
+                        quality_notes, [{"type":"qualitative_quote_rendering","reason":str(exc)[:500]}],
+                        section_name="Findings", stage="final_quote_review"
+                    )
                 repeated_quotes = agent.find_repeated_qualitative_quotes(full_draft_en, data_metadata)
                 if repeated_quotes:
-                    raise RuntimeError(f"Repeated qualitative quotations: {repeated_quotes[:5]}")
+                    self._record_adaptive_completion_residual(
+                        quality_notes, [{"type":"qualitative_quote_repetition","reason":str(repeated_quotes[:5])}],
+                        section_name="Findings", stage="final_quote_review"
+                    )
             # R4-R3: the body is already citation-resolved at this point. Never
             # rescan it for raw CITE tags; that destroys a valid citation ledger.
             final_citation_ledger = agent.finalize_resolved_citation_ledger(full_draft_en)
@@ -4677,22 +4833,14 @@ The previous attempt for this same manuscript unit was rejected by validation. R
                         final_abstract, hypothesis_ledger, section_name="Final Abstract"
                     ))
                 if remaining_final_fact_rows:
-                    state["final_abstract_retry_exhausted"] = {
-                        "attempts": 2,
-                        "violations": copy.deepcopy(remaining_final_fact_rows[:12]),
-                        "semantic_integrity_corruption": False,
-                    }
-                    state.update({
-                        "agent_state": agent.export_state(),
-                        "quality_diagnostics": quality_diagnostics,
-                    })
-                    self._checkpoint(
-                        "final_abstract_retry_exhausted", state, 92,
-                        display_node="final_abstract_retry_exhausted",
-                    )
-                    raise RuntimeError(
-                        f"final_abstract_invalid_after_retry:{remaining_final_fact_rows[:3]}"
+                    final_abstract, residual_final_rows = self._adaptive_repair_front_matter(
+                        agent=agent, quant_engine=quant_engine, abstract_text=final_abstract,
+                        violations=remaining_final_fact_rows, mode=mode, data_metadata=data_metadata,
+                        study_evidence=user_data_md, hypothesis_ledger=hypothesis_ledger,
+                        quality_notes=quality_notes, label="Final Abstract",
                     )
+                    if residual_final_rows:
+                        logging.warning("Adaptive Final Abstract accepted with residual diagnostics | count=%s", len(residual_final_rows))
                 quality_diagnostics.append({
                     "scope":"final_abstract_study_fact_integrity", "name":"Final Abstract",
                     "status":"front_matter_retry_resolved", "count":len(final_front_fact_rows),
@@ -4706,8 +4854,9 @@ The previous attempt for this same manuscript unit was rejected by validation. R
                     full_draft_en, hypothesis_ledger, section_name="Full Manuscript", require_all=True
                 )
                 if post_front_hypothesis_rows:
-                    raise RuntimeError(
-                        f"final_hypothesis_contract_failed_after_front_matter:{post_front_hypothesis_rows[:3]}"
+                    self._record_adaptive_completion_residual(
+                        quality_notes, post_front_hypothesis_rows, section_name="Final Abstract",
+                        stage="post_front_matter_hypothesis_review"
                     )
             body_only, _reference_tail = agent.validate_reference_tail(
                 full_draft_en, minimum_references=final_reference_count
@@ -4867,10 +5016,31 @@ The previous attempt for this same manuscript unit was rejected by validation. R
                         f'translation_{unit_key}_repair_pending', state, pct,
                         display_node=f'translation_repair_pending:{index}:{len(final_units)}',
                     )
-                    # Stop at the first blocking unit. The durable claim state is
-                    # now checkpointed, so resume continues exactly here instead
-                    # of spending tokens on later units or repeating prior repair.
-                    raise RuntimeError('translation_final_gate_unresolved:' + str(unit_key))
+                    # A2: strict claim QA is diagnostic/recovery authority, not a
+                    # manuscript kill switch. Escalate the same frozen source to
+                    # a whole-unit provider-neutral fallback and keep going.
+                    fallback = translation_agent.adaptive_translate_fallback(
+                        translation_source, target_lang, section_name=unit_name, glossary=translation_glossary
+                    )
+                    current_translation.update({
+                        'translated_text': str(fallback.get('text') or '').strip(),
+                        'qa_status': str(fallback.get('qa_status') or 'passed_with_warning'),
+                        'diagnostics': list(current_translation.get('diagnostics') or []) + list(fallback.get('diagnostics') or []),
+                        'error_code': '',
+                        'adaptive_completion_fallback': True,
+                    })
+                    translation_sections[unit_key] = current_translation
+                    if mode == "amj" and str(unit_key).strip().casefold() == "results":
+                        table_manifest = dict(data_metadata.get("quantitative_table_manifest") or {})
+                        if table_manifest and current_translation.get('translated_text'):
+                            current_translation['translated_text'] = quant_engine.bind_target_language_quantitative_tables(
+                                current_translation.get('translated_text'), table_manifest, target_lang, translation_glossary
+                            )
+                            translation_sections[unit_key] = current_translation
+                    self._record_adaptive_completion_residual(
+                        quality_notes, [{'type':'translation_strict_gate_fallback','reason':str(state.get('translation_blocking_error_code') or '')}],
+                        section_name=unit_name, stage='translation_fallback'
+                    )
                 state.pop('translation_blocking_unit', None)
                 state.pop('translation_blocking_unit_name', None)
                 state.pop('translation_blocking_error_code', None)
@@ -4885,7 +5055,15 @@ The previous attempt for this same manuscript unit was rejected by validation. R
                 or not (translation_sections.get(key) or {}).get('translated_text')
             ]
             if unresolved_units:
-                raise RuntimeError('translation_final_gate_unresolved:' + ','.join(unresolved_units[:8]))
+                # A2 should normally resolve these inside the per-unit fallback.
+                # Keep the manuscript moving if a stale checkpoint status remains
+                # but usable translated text exists; empty target text is still an
+                # infrastructure/completion failure and cannot produce a document.
+                empty_units = [key for key in unresolved_units if not (translation_sections.get(key) or {}).get('translated_text')]
+                if empty_units:
+                    raise RuntimeError('translation_output_missing:' + ','.join(empty_units[:8]))
+                for key in unresolved_units:
+                    translation_sections[key]['qa_status'] = 'passed_with_warning'
             full_draft_translated = self._assemble_partial_translation(
                 translation_sections, adaptive_structure, include_front=True
             ).rstrip()
@@ -4897,11 +5075,23 @@ The previous attempt for this same manuscript unit was rejected by validation. R
             )
             if mode == "asq":
                 appendix_manifest = qual_engine.build_appendix_manifest(data_metadata)
-                qual_engine.validate_bound_target_appendix(
-                    full_draft_translated, appendix_manifest, target_lang
+                try:
+                    qual_engine.validate_bound_target_appendix(
+                        full_draft_translated, appendix_manifest, target_lang
+                    )
+                except Exception as exc:
+                    self._record_adaptive_completion_residual(
+                        quality_notes, [{'type':'target_qualitative_appendix_review','reason':str(exc)[:500]}],
+                        section_name='Appendix', stage='translation_final_review'
+                    )
+            try:
+                agent.validate_translation_alignment(full_draft_en, full_draft_translated)
+                agent.validate_reference_preservation(full_draft_en, full_draft_translated, target_lang)
+            except Exception as exc:
+                self._record_adaptive_completion_residual(
+                    quality_notes, [{'type':'translation_final_alignment_review','reason':str(exc)[:500]}],
+                    section_name='Target-language manuscript', stage='translation_final_review'
                 )
-            agent.validate_translation_alignment(full_draft_en, full_draft_translated)
-            agent.validate_reference_preservation(full_draft_en, full_draft_translated, target_lang)
             self._publish_target_preview(
                 full_draft_translated, 'translation_complete', force=True, complete=True
             )
@@ -4940,17 +5130,24 @@ The previous attempt for this same manuscript unit was rejected by validation. R
 
         self._progress(97, "packaging")
         bj_time = datetime.now(timezone(timedelta(hours=8))).strftime("%Y%m%d_%H%M")
+        target_file_language = (
+            "Chinese" if "chinese" in target_lang.casefold() or "中文" in target_lang
+            else "Russian" if "russian" in target_lang.casefold() or "рус" in target_lang.casefold()
+            else "Kazakh" if "kazakh" in target_lang.casefold() or "қазақ" in target_lang.casefold()
+            else re.sub(r"[^A-Za-z]+", "", output_suffix) or "Target"
+        )
         package = build_validated_package(
             english_markdown=full_draft_en,
             translated_markdown=full_draft_translated,
-            english_filename=f"Research_EN_{bj_time}.docx",
-            translated_filename=f"Research_{output_suffix}_{bj_time}.docx",
+            english_filename="Paper_English.docx",
+            translated_filename=f"Paper_{target_file_language}.docx",
             data_metadata=data_metadata,
             mode=mode,
             citation_audit=agent.citation_audit_log,
             literature_metrics=agent.get_source_metrics(),
             quality_diagnostics=quality_diagnostics,
             quality_notes=quality_notes,
+            organize_appendix=True,
             evidence_coverage=state.get("evidence_coverage_summary") or {
                 "status": str(state.get("evidence_status") or "adequate"),
                 "early_risk_detected": bool(state.get("evidence_risk_detected")),

core/model_gateway.py

@@ -0,0 +1,185 @@
+# -*- coding: utf-8 -*-
+"""Provider-neutral model routing primitives for SmartPaper.
+
+A2 keeps the currently verified DeepSeek transport intact while moving provider
+selection out of academic business logic.  Providers are registered adapters;
+academic code asks for a capability (reasoning/writing/translation/fast/repair)
+and never needs to know the concrete vendor or model name.
+"""
+from __future__ import annotations
+
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import Any, Callable, Iterable
+
+
+class ModelGatewayError(RuntimeError):
+    pass
+
+
+class ModelProviderUnavailableError(ModelGatewayError):
+    pass
+
+
+class ModelAuthenticationError(ModelGatewayError):
+    pass
+
+
+class ModelBalanceError(ModelGatewayError):
+    pass
+
+
+class ModelRequestError(ModelGatewayError):
+    pass
+
+
+@dataclass(frozen=True)
+class ModelRoute:
+    provider: str
+    provider_role: str
+    fallback_providers: tuple[str, ...] = ()
+
+
+class ProviderNeutralModelGateway:
+    """Route capability calls to registered provider adapters.
+
+    Adapter callables intentionally share the existing PipelineAgent request
+    signature.  This makes A2 a low-risk architectural seam: DeepSeek remains
+    the verified adapter today, while Gemini/Qwen/OpenAI adapters can be
+    registered later without changing manuscript generation code.
+    """
+
+    def __init__(self, config: dict[str, Any] | None = None):
+        cfg = dict(config or {})
+        self.default_provider = str(cfg.get("default_provider") or "deepseek").strip().lower()
+        raw_routes = dict(cfg.get("capability_routes") or {})
+        self._routes: dict[str, ModelRoute] = {}
+        for capability, row in raw_routes.items():
+            cap = str(capability or "").strip().lower()
+            if not cap:
+                continue
+            if isinstance(row, str):
+                provider = str(row or self.default_provider).strip().lower()
+                provider_role = cap
+            else:
+                item = dict(row or {})
+                provider = str(item.get("provider") or self.default_provider).strip().lower()
+                provider_role = str(item.get("provider_role") or cap).strip().lower()
+                raw_fallbacks = item.get("fallback_providers") or ()
+                if isinstance(raw_fallbacks, str):
+                    raw_fallbacks = [part.strip() for part in raw_fallbacks.split(",") if part.strip()]
+                fallbacks = tuple(
+                    str(name or "").strip().lower()
+                    for name in raw_fallbacks
+                    if str(name or "").strip()
+                )
+            if not isinstance(row, dict):
+                fallbacks = ()
+            self._routes[cap] = ModelRoute(provider=provider, provider_role=provider_role, fallback_providers=fallbacks)
+        self._call_adapters: dict[str, Callable[..., str]] = {}
+        self._stream_adapters: dict[str, Callable[..., Iterable[str]]] = {}
+        self._policy_snapshot: dict[str, Any] = {}
+
+    def register_provider(
+        self,
+        provider: str,
+        *,
+        call_adapter: Callable[..., str],
+        stream_adapter: Callable[..., Iterable[str]],
+    ) -> None:
+        name = str(provider or "").strip().lower()
+        if not name:
+            raise ValueError("provider name is required")
+        self._call_adapters[name] = call_adapter
+        self._stream_adapters[name] = stream_adapter
+
+    def set_policy_snapshot(self, snapshot: dict[str, Any] | None) -> None:
+        self._policy_snapshot = deepcopy(dict(snapshot or {}))
+
+    @property
+    def policy_snapshot(self) -> dict[str, Any]:
+        return deepcopy(self._policy_snapshot)
+
+    def _route(self, capability: str) -> ModelRoute:
+        cap = str(capability or "reasoning").strip().lower() or "reasoning"
+        policy_routes = dict(self._policy_snapshot.get("model_routes") or {})
+        row = policy_routes.get(cap)
+        if isinstance(row, str):
+            return ModelRoute(provider=row.strip().lower(), provider_role=cap)
+        if isinstance(row, dict):
+            raw_fallbacks = row.get("fallback_providers") or ()
+            if isinstance(raw_fallbacks, str):
+                raw_fallbacks = [part.strip() for part in raw_fallbacks.split(",") if part.strip()]
+            return ModelRoute(
+                provider=str(row.get("provider") or self.default_provider).strip().lower(),
+                provider_role=str(row.get("provider_role") or cap).strip().lower(),
+                fallback_providers=tuple(
+                    str(name or "").strip().lower() for name in raw_fallbacks
+                    if str(name or "").strip()
+                ),
+            )
+        return self._routes.get(cap) or ModelRoute(self.default_provider, cap)
+
+    @staticmethod
+    def _provider_sequence(route: ModelRoute) -> tuple[str, ...]:
+        return tuple(dict.fromkeys(
+            name for name in (route.provider, *route.fallback_providers) if name
+        ))
+
+    def call(self, *, capability: str, **kwargs) -> str:
+        route = self._route(capability)
+        missing = []
+        for provider in self._provider_sequence(route):
+            adapter = self._call_adapters.get(provider)
+            if not callable(adapter):
+                missing.append(provider)
+                continue
+            payload = dict(kwargs)
+            payload["model_role"] = route.provider_role
+            return adapter(**payload)
+        raise ModelProviderUnavailableError(
+            f"model_provider_unavailable:{','.join(missing) or route.provider}:{capability}"
+        )
+
+    def stream(self, *, capability: str, **kwargs):
+        route = self._route(capability)
+        missing = []
+        for provider in self._provider_sequence(route):
+            adapter = self._stream_adapters.get(provider)
+            if not callable(adapter):
+                missing.append(provider)
+                continue
+            payload = dict(kwargs)
+            payload["model_role"] = route.provider_role
+            yield from adapter(**payload)
+            return
+        raise ModelProviderUnavailableError(
+            f"model_provider_unavailable:{','.join(missing) or route.provider}:{capability}"
+        )
+
+
+def resolve_plan_policy_snapshot(
+    app_config: dict[str, Any], request: dict[str, Any] | None = None
+) -> dict[str, Any]:
+    """Freeze a config-driven plan policy without touching payment authority.
+
+    A2 only creates the interface.  Worker/D1 remain the authority for payment,
+    quota and entitlement; if the request does not yet carry a trusted plan_id,
+    the legacy-current policy preserves existing production behavior.
+    """
+    req = dict(request or {})
+    policies = dict(app_config.get("plan_policies") or {})
+    # Never trust a browser/request plan label as an entitlement authority.
+    # A future Worker/D1 integration may inject a trusted entitlement snapshot;
+    # until then every task stays on the legacy-current production policy.
+    entitlement = req.get("entitlement_snapshot") if isinstance(req.get("entitlement_snapshot"), dict) else {}
+    requested = str(
+        req.get("trusted_plan_id") or entitlement.get("plan_id") or ""
+    ).strip().lower()
+    selected = requested if requested in policies else "legacy_current"
+    policy = deepcopy(dict(policies.get(selected) or policies.get("legacy_current") or {}))
+    policy["plan_id"] = selected
+    policy["policy_version"] = str(
+        policy.get("policy_version") or app_config.get("plan_policy_version") or "plan-policy-v1"
+    )
+    return policy

core/pipeline_agent.py

@@ -28,6 +28,7 @@ except ImportError:
 
 from config import APP_CONFIG
 from core.production_guard import find_authorial_ai_meta_spans
+from core.model_gateway import ProviderNeutralModelGateway
 
 
 class DeepSeekAPIError(RuntimeError):
@@ -104,13 +105,12 @@ class SSciPipelineAgent:
                 families.append(code)
         return tuple(dict.fromkeys(families)) or ('UNKNOWN',)
 
-    def __init__(self, ds_key, s2_key=""):
+    def __init__(self, ds_key="", s2_key=""):
         self.ds_key = str(ds_key or "").strip()
-        if not self.ds_key:
-            raise DeepSeekAuthenticationError(
-                "DEEPSEEK_API_KEY is empty. Configure it in Hugging Face "
-                "Space Settings > Variables and secrets."
-            )
+        self.model_gateway_config = dict(APP_CONFIG.get("model_gateway") or {})
+        # Provider credentials are adapter-owned and validated only when that
+        # provider is actually selected.  This is essential for future plan
+        # policies that may route every capability away from DeepSeek.
         # R3-Free: the generation engine is headless. Hugging Face Secrets are
         # exposed to the process as environment variables; Streamlit is not a
         # dependency of the executor or pipeline.
@@ -187,22 +187,6 @@ class SSciPipelineAgent:
             str(role).strip().lower(): str(model or "").strip()
             for role, model in configured_models.items()
         }
-        required_roles = {
-            "reasoning",
-            "writing",
-            "translation",
-            "fast",
-            "fallback",
-        }
-        missing_roles = [
-            role for role in required_roles
-            if not self.deepseek_models.get(role)
-        ]
-        if missing_roles:
-            raise DeepSeekRequestError(
-                "Missing DeepSeek model role configuration: "
-                + ", ".join(sorted(missing_roles))
-            )
         self.deepseek_task_settings = APP_CONFIG.get(
             "deepseek_task_settings",
             {},
@@ -224,6 +208,16 @@ class SSciPipelineAgent:
             20,
             int(APP_CONFIG.get("deepseek_stream_idle_seconds", 60)),
         )
+        self.model_gateway = ProviderNeutralModelGateway(self.model_gateway_config)
+        # A2 registers the already-verified DeepSeek transport as one provider
+        # adapter.  Future provider adapters can be added here without changing
+        # academic generation, translation, or repair call sites.
+        self.model_gateway.register_provider(
+            "deepseek",
+            call_adapter=self._call_deepseek_transport,
+            stream_adapter=self._stream_deepseek_transport,
+        )
+        self.model_policy_snapshot = {}
         
         self.global_memory = {
             "hypotheses": "", "variables": "", "model_summary": "",
@@ -797,7 +791,7 @@ class SSciPipelineAgent:
                 model = fallback_model
             yield attempt, model, thinking
 
-    def call_deepseek(
+    def _call_deepseek_transport(
         self,
         system_prompt,
         user_prompt,
@@ -810,6 +804,10 @@ class SSciPipelineAgent:
         allow_fallback=None,
         response_format=None,
     ):
+        if not str(getattr(self, "ds_key", "") or "").strip():
+            raise DeepSeekAuthenticationError(
+                "DEEPSEEK_API_KEY is empty for the selected DeepSeek provider adapter."
+            )
         (
             requested_model,
             requested_thinking,
@@ -944,7 +942,7 @@ class SSciPipelineAgent:
             f"{self.deepseek_max_retries} attempts: {last_error}"
         )
 
-    def stream_deepseek(
+    def _stream_deepseek_transport(
         self,
         system_prompt,
         user_prompt,
@@ -957,6 +955,10 @@ class SSciPipelineAgent:
         allow_fallback=None,
         reasoning_only_recovery=False,
     ):
+        if not str(getattr(self, "ds_key", "") or "").strip():
+            raise DeepSeekAuthenticationError(
+                "DEEPSEEK_API_KEY is empty for the selected DeepSeek provider adapter."
+            )
         (
             requested_model,
             requested_thinking,
@@ -1181,6 +1183,79 @@ class SSciPipelineAgent:
             f"{self.deepseek_max_retries} attempts: {last_error}"
         )
 
+    def set_model_policy_snapshot(self, snapshot):
+        self.model_policy_snapshot = dict(snapshot or {})
+        self.model_gateway.set_policy_snapshot(self.model_policy_snapshot)
+
+    def call_model(
+        self, system_prompt, user_prompt, max_tokens=8000, temp=0.3,
+        model_name=None, model_role="reasoning", thinking=None,
+        reasoning_effort=None, allow_fallback=None, response_format=None,
+    ):
+        gateway = getattr(self, "model_gateway", None)
+        if gateway is None:
+            # Unit-test / old-checkpoint compatibility for agents constructed
+            # without __init__. Production instances always own a gateway.
+            return self._call_deepseek_transport(
+                system_prompt, user_prompt, max_tokens=max_tokens, temp=temp,
+                model_name=model_name, model_role=model_role, thinking=thinking,
+                reasoning_effort=reasoning_effort, allow_fallback=allow_fallback,
+                response_format=response_format,
+            )
+        return gateway.call(
+            capability=model_role, system_prompt=system_prompt, user_prompt=user_prompt,
+            max_tokens=max_tokens, temp=temp, model_name=model_name,
+            thinking=thinking, reasoning_effort=reasoning_effort,
+            allow_fallback=allow_fallback, response_format=response_format,
+        )
+
+    def stream_model(
+        self, system_prompt, user_prompt, max_tokens=8000, model_name=None,
+        model_role="reasoning", thinking=None, reasoning_effort=None, temp=0.3,
+        allow_fallback=None, reasoning_only_recovery=False,
+    ):
+        gateway = getattr(self, "model_gateway", None)
+        if gateway is None:
+            yield from self._stream_deepseek_transport(
+                system_prompt, user_prompt, max_tokens=max_tokens, model_name=model_name,
+                model_role=model_role, thinking=thinking, reasoning_effort=reasoning_effort,
+                temp=temp, allow_fallback=allow_fallback,
+                reasoning_only_recovery=reasoning_only_recovery,
+            )
+            return
+        yield from gateway.stream(
+            capability=model_role, system_prompt=system_prompt, user_prompt=user_prompt,
+            max_tokens=max_tokens, model_name=model_name, thinking=thinking,
+            reasoning_effort=reasoning_effort, temp=temp, allow_fallback=allow_fallback,
+            reasoning_only_recovery=reasoning_only_recovery,
+        )
+
+    # Compatibility aliases retained for the existing verified test surface and
+    # older engines.  Runtime routing is provider-neutral through call_model.
+    def call_deepseek(
+        self, system_prompt, user_prompt, max_tokens=8000, temp=0.3,
+        model_name=None, model_role="reasoning", thinking=None,
+        reasoning_effort=None, allow_fallback=None, response_format=None,
+    ):
+        return self.call_model(
+            system_prompt, user_prompt, max_tokens=max_tokens, temp=temp,
+            model_name=model_name, model_role=model_role, thinking=thinking,
+            reasoning_effort=reasoning_effort, allow_fallback=allow_fallback,
+            response_format=response_format,
+        )
+
+    def stream_deepseek(
+        self, system_prompt, user_prompt, max_tokens=8000, model_name=None,
+        model_role="reasoning", thinking=None, reasoning_effort=None, temp=0.3,
+        allow_fallback=None, reasoning_only_recovery=False,
+    ):
+        yield from self.stream_model(
+            system_prompt, user_prompt, max_tokens=max_tokens, model_name=model_name,
+            model_role=model_role, thinking=thinking, reasoning_effort=reasoning_effort,
+            temp=temp, allow_fallback=allow_fallback,
+            reasoning_only_recovery=reasoning_only_recovery,
+        )
+
     def parse_user_core_literature(self, user_lit_text):
         if not user_lit_text.strip(): 
             return ""
@@ -5759,10 +5834,21 @@ SECTION ROLE: {profile}
 EVIDENCE CONTRACT: {evidence_contract[:4500]}
 TEXT:
 {value}"""
-        raw = self.call_deepseek(
-            'You are an independent senior management-journal reviewer. Be exact and conservative.',
-            prompt, max_tokens=800, temp=0.0, model_role='fast', thinking=False, allow_fallback=True,
-        )
+        try:
+            # Compatibility entrypoint; production call_deepseek is now only
+            # an alias into the provider-neutral model gateway.
+            raw = self.call_deepseek(
+                'You are an independent senior management-journal reviewer. Be exact and conservative.',
+                prompt, max_tokens=800, temp=0.0, model_role='fast', thinking=False, allow_fallback=True,
+            )
+        except PipelineCancelledError:
+            raise
+        except Exception as exc:
+            logging.warning(
+                'Optional top-journal critic unavailable; continuing without critic | section=%s error=%s',
+                section_name or section_id, type(exc).__name__,
+            )
+            return {'pass': True, 'critical_issue': '', 'repair_instruction': ''}
         parsed = self._extract_json_from_text(raw)
         if not isinstance(parsed, dict) or parsed.get('pass') is not False:
             return {'pass': True, 'critical_issue': '', 'repair_instruction': ''}
@@ -5772,6 +5858,83 @@ TEXT:
             return {'pass': True, 'critical_issue': '', 'repair_instruction': ''}
         return {'pass': False, 'critical_issue': issue[:800], 'repair_instruction': instruction[:1200]}
 
+    def adaptive_repair_academic_unit(
+        self, text, *, violations, section_id='', section_name='', mode='amj',
+        study_evidence='', evidence_contract='', repair_scope='section',
+    ):
+        """A2 provider-neutral semantic repair for exhausted academic content.
+
+        The model may rewrite prose, but it may not invent study facts, numeric
+        results, citations, methods, hypotheses, or quotations.  Deterministic
+        validators remain the source of truth and re-check the returned text.
+        """
+        value = str(text or '').strip()
+        if not value:
+            return value
+        feedback_rows = []
+        for row in list(violations or [])[:12]:
+            if isinstance(row, dict):
+                feedback_rows.append({
+                    'type': str(row.get('type') or 'validation_issue'),
+                    'reason': str(row.get('repair_instruction') or row.get('reason') or row.get('preview') or '')[:500],
+                    'observed': row.get('observed'),
+                    'expected': row.get('expected'),
+                })
+            else:
+                feedback_rows.append({'type': 'validation_issue', 'reason': str(row)[:500]})
+        prompt = f"""Repair the academic manuscript unit below. Return ONLY the revised reader-facing unit.
+
+REPAIR SCOPE: {str(repair_scope or 'section').upper()}
+RESEARCH MODE: {'QUALITATIVE' if str(mode).lower() == 'asq' else 'QUANTITATIVE'}
+SECTION ID: {section_id}
+SECTION NAME: {section_name}
+
+NON-NEGOTIABLE RULES:
+1. Preserve the study's actual design, actors, sample, measures, methods, statistics, hypotheses, themes, quotations, and evidence boundaries.
+2. Do not invent or import any numeric value, citation, bibliographic identity, quotation, method, participant, data source, or result.
+3. Existing citations may be removed, narrowed, or repositioned only to correct support; never create a new citation identity.
+4. Preserve direct qualitative quotations verbatim.
+5. For observational/cross-sectional quantitative work, use association/covariation language unless causal identification is explicitly supported by the locked study evidence.
+6. Write concise, accurate, rigorous academic prose. Do not mention validation, repair, prompts, AI, ledgers, orchestration, or internal workflow.
+7. Resolve the listed defects while keeping the section role and logical continuity.
+
+VALIDATION DEFECTS:
+{json.dumps(feedback_rows, ensure_ascii=False)}
+
+LOCKED STUDY EVIDENCE:
+{str(study_evidence or '')[:12000]}
+
+AUTHORIZED EVIDENCE CONTEXT:
+{str(evidence_contract or '')[:8000]}
+
+CURRENT UNIT:
+{value}
+"""
+        try:
+            repaired = self.call_model(
+                'You are SmartPaper Adaptive Academic Repair. Preserve evidence truth and repair prose with Conciseness, Accuracy, and Rigor.',
+                prompt, max_tokens=7000, temp=0.15, model_role='repair', thinking=True, allow_fallback=True,
+            )
+        except PipelineCancelledError:
+            raise
+        except Exception as exc:
+            # A repair-provider failure must not destroy an otherwise complete
+            # academic unit.  Revalidation will preserve the residual as an
+            # Appendix advisory; core writer/provider outages remain handled at
+            # their actual generation boundary.
+            self._last_adaptive_repair_diagnostic = {
+                'status': 'repair_provider_unavailable',
+                'error_type': type(exc).__name__,
+                'section': str(section_name or section_id or ''),
+            }
+            logging.warning(
+                'Adaptive academic repair unavailable; retaining complete source unit | section=%s error=%s',
+                section_name or section_id, type(exc).__name__,
+            )
+            return value
+        repaired = re.sub(r'<think>.*?</think>', '', str(repaired or ''), flags=re.S).strip()
+        return repaired or value
+
     def critique_and_repair_section(self, text, *, section_id, section_name, mode, evidence_contract=''):
         """Legacy compatibility wrapper. Active S0-R1 path uses critique_section().
 
@@ -10286,6 +10449,75 @@ Decision must be CONFIRMED_BLOCKING or NOT_CONFIRMED. evidence_code must be one
                     raise
         raise last_error or DeepSeekRequestError('Translation section QA failed.')
 
+    def adaptive_translate_fallback(self, section_text, target_lang, *, section_name='', glossary=None):
+        """A2 final content fallback after strict claim QA cannot converge.
+
+        This is intentionally less brittle than the claim-level strict gate but
+        still requires a complete target-language unit with the same heading
+        tree.  References are never sent here by the runner.
+        """
+        value = str(section_text or '').strip()
+        if not value:
+            raise DeepSeekRequestError('Adaptive translation fallback received empty source.')
+        attempts = max(1, int((APP_CONFIG.get('adaptive_completion') or {}).get('translation_fallback_passes', 1)))
+        last_error = None
+        for _attempt in range(attempts):
+            try:
+                translated = self.translate_locked_manuscript(value, target_lang)
+                self.validate_translation_alignment(value, translated)
+                self._validate_translation_language_quality(translated, target_lang)
+                return {
+                    'text': translated,
+                    'qa_status': 'passed_with_warning',
+                    'diagnostics': [{
+                        'code': 'ADAPTIVE_TRANSLATION_FALLBACK',
+                        'section': str(section_name or ''),
+                        'decision': 'ACCEPT_AFTER_FALLBACK',
+                    }],
+                }
+            except PipelineCancelledError:
+                raise
+            except (DeepSeekAuthenticationError, DeepSeekBalanceError):
+                raise
+            except Exception as exc:
+                last_error = exc
+                logging.warning('Adaptive translation fallback retry | section=%s error=%s', section_name or 'section', type(exc).__name__)
+
+        # Final semantic escape hatch: ask the configured translation capability
+        # for a whole-unit faithful rewrite.  This path is used only after the
+        # stricter claim compiler/QA cannot converge; it still preserves the
+        # frozen source and requires non-empty target prose.
+        prompt = f"""Translate the complete frozen English manuscript unit into {target_lang}.
+Return ONLY the translated Markdown unit.
+Preserve every heading level and order, every number/statistic/date, every citation already present, every hypothesis identity, and every direct quotation exactly in meaning. Do not add facts, citations, methods, results, or commentary. Use natural academic language and keep the argument logically equivalent to the English source.
+
+SOURCE UNIT:
+{value}
+"""
+        translated = self.call_model(
+            'You are SmartPaper Adaptive Translation. Produce faithful academic translation with no added or omitted claims.',
+            prompt, max_tokens=8000, temp=0.1, model_role='translation', thinking=False, allow_fallback=True,
+        )
+        translated = re.sub(r'<think>.*?</think>', '', str(translated or ''), flags=re.S).strip()
+        if not translated:
+            raise last_error or DeepSeekRequestError('Adaptive translation fallback failed.')
+        diagnostics = [{
+            'code': 'ADAPTIVE_TRANSLATION_WHOLE_UNIT_FALLBACK',
+            'section': str(section_name or ''),
+            'decision': 'ACCEPT_AFTER_FALLBACK',
+            'prior_error': type(last_error).__name__ if last_error else '',
+        }]
+        try:
+            self.validate_translation_alignment(value, translated)
+            self._validate_translation_language_quality(translated, target_lang)
+        except Exception as exc:
+            diagnostics.append({
+                'code': 'ADAPTIVE_TRANSLATION_RESIDUAL_DIAGNOSTIC',
+                'decision': 'PASS_WITH_WARNING',
+                'detail': self._safe_source_error(exc),
+            })
+        return {'text': translated, 'qa_status': 'passed_with_warning', 'diagnostics': diagnostics}
+
     def translate_locked_manuscript(self, manuscript, target_lang):
         value = str(manuscript or '').strip()
         if not value:

core/production_guard.py

@@ -685,6 +685,7 @@ def build_validated_package(
     quality_diagnostics: list[dict[str, Any]] | None = None,
     quality_notes: list[dict[str, Any]] | None = None,
     evidence_coverage: dict[str, Any] | None = None,
+    organize_appendix: bool = False,
 ) -> PackageResult:
     validate_markdown_manuscript(english_markdown, language_name="English")
     validate_markdown_manuscript(translated_markdown, language_name="Target-language")
@@ -713,18 +714,19 @@ def build_validated_package(
         validate_qualitative_appendix_docx_layout(english_docx, label="English DOCX")
         validate_qualitative_appendix_docx_layout(translated_docx, label="Target-language DOCX")
 
+    appendix_prefix = "Appendix/" if organize_appendix else ""
     entries: dict[str, bytes] = {
         english_filename: english_docx,
         translated_filename: translated_docx,
-        "GENERATION_NOTES.txt": build_generation_notes(data_metadata, mode).encode("utf-8"),
-        "CITATION_AUDIT.json": json.dumps(citation_audit or [], ensure_ascii=False, indent=2).encode("utf-8"),
-        "LITERATURE_METRICS.json": json.dumps(literature_metrics or {}, ensure_ascii=False, indent=2).encode("utf-8"),
-        "WORD_COUNT_QUALITY_REPORT.txt": build_word_count_quality_report(quality_diagnostics).encode("utf-8"),
-        "SmartPaper_Quality_Notes.txt": build_quality_notes(quality_notes).encode("utf-8"),
-        "EVIDENCE_COVERAGE_REPORT.txt": build_evidence_coverage_report(evidence_coverage).encode("utf-8"),
+        appendix_prefix + "GENERATION_NOTES.txt": build_generation_notes(data_metadata, mode).encode("utf-8"),
+        appendix_prefix + "CITATION_AUDIT.json": json.dumps(citation_audit or [], ensure_ascii=False, indent=2).encode("utf-8"),
+        appendix_prefix + "LITERATURE_METRICS.json": json.dumps(literature_metrics or {}, ensure_ascii=False, indent=2).encode("utf-8"),
+        appendix_prefix + "WORD_COUNT_QUALITY_REPORT.txt": build_word_count_quality_report(quality_diagnostics).encode("utf-8"),
+        appendix_prefix + "SmartPaper_Quality_Notes.txt": build_quality_notes(quality_notes).encode("utf-8"),
+        appendix_prefix + "EVIDENCE_COVERAGE_REPORT.txt": build_evidence_coverage_report(evidence_coverage).encode("utf-8"),
     }
     manifest = _manifest(entries)
-    entries["FILE_MANIFEST_SHA256.txt"] = manifest.encode("utf-8")
+    entries[appendix_prefix + "FILE_MANIFEST_SHA256.txt"] = manifest.encode("utf-8")
 
     buffer = io.BytesIO()
     with zipfile.ZipFile(buffer, "w", zipfile.ZIP_DEFLATED) as archive:

core/quantitative_engine.py

@@ -1453,6 +1453,122 @@ Keywords: {keywords}"""
             return False
         return True
 
+    @staticmethod
+    def _normalize_quantitative_construct_surface(value):
+        """Normalize a construct surface for conservative alias matching."""
+        text = str(value or "").casefold()
+        text = re.sub(r"[^a-z0-9]+", " ", text)
+        return re.sub(r"\s+", " ", text).strip()
+
+    @classmethod
+    def _quantitative_construct_alias_map(cls, constructs):
+        """Return only unique, conservative aliases for frozen construct names.
+
+        R6-R14 permits ordinary abstract compression such as
+        ``medical tourism conversion intention`` -> ``conversion intention``.
+        Aliases are suffixes of at least two lexical tokens and are admitted only
+        when they identify exactly one frozen construct role.  No semantic model
+        or fuzzy embedding is used, so ambiguous aliases remain unresolved.
+        """
+        role_values = {
+            str(role): cls._normalize_quantitative_construct_surface(value)
+            for role, value in dict(constructs or {}).items()
+            if str(value or "").strip()
+        }
+        candidates = {}
+        for role, canonical in role_values.items():
+            tokens = canonical.split()
+            surfaces = {canonical}
+            # Conservative reader-facing shortening: terminal 2-4 token suffixes.
+            # One-word aliases (e.g. "intention") are intentionally forbidden.
+            for width in range(2, min(4, len(tokens)) + 1):
+                if width < len(tokens):
+                    alias = " ".join(tokens[-width:])
+                    if len(alias) >= 8:
+                        surfaces.add(alias)
+            for surface in surfaces:
+                candidates.setdefault(surface, set()).add(role)
+        unique = {surface: next(iter(roles)) for surface, roles in candidates.items() if len(roles) == 1}
+        by_role = {role: [] for role in role_values}
+        for surface, role in unique.items():
+            by_role.setdefault(role, []).append(surface)
+        for role in by_role:
+            by_role[role] = sorted(set(by_role[role]), key=lambda x: (-len(x), x))
+        return by_role
+
+    @classmethod
+    def _quantitative_construct_roles_in_text(cls, text, constructs):
+        folded = cls._normalize_quantitative_construct_surface(text)
+        roles = set()
+        aliases = cls._quantitative_construct_alias_map(constructs)
+        for role, surfaces in aliases.items():
+            for surface in surfaces:
+                if re.search(rf"(?<![a-z0-9]){re.escape(surface)}(?![a-z0-9])", folded):
+                    roles.add(role)
+                    break
+        return roles
+
+    @staticmethod
+    def _quantitative_metric_local_clause(sentence, metric_start, metric_end):
+        """Bound one metric occurrence to its nearest relation clause.
+
+        Strong punctuation/conjunction boundaries are preferred.  If two metric
+        occurrences remain in one span, an ``and`` between those metric surfaces
+        becomes a boundary.  This avoids treating two path estimates in one
+        sentence as if they shared a single owner while not splitting construct
+        names such as ``triage and itinerary planning``.
+        """
+        text = str(sentence or "")
+        metric_re = re.compile(r"(?i)(?:β|standardized\s+estimate)\s*(?:=|:)?\s*[-+]?\d+(?:\.\d+)?")
+        metrics = list(metric_re.finditer(text))
+        boundaries = [0, len(text)]
+        for match in re.finditer(r"(?i);|,\s+(?:and|but|while|whereas)\s+|\b(?:however|nevertheless)\b", text):
+            boundaries.extend([match.start(), match.end()])
+        # Conjunctions between adjacent metric occurrences are relation boundaries.
+        for left, right in zip(metrics, metrics[1:]):
+            between = text[left.end():right.start()]
+            joins = list(re.finditer(r"(?i)\band\b", between))
+            if joins:
+                join = joins[-1]
+                boundaries.extend([left.end() + join.start(), left.end() + join.end()])
+        left = max((b for b in boundaries if b <= metric_start), default=0)
+        right = min((b for b in boundaries if b >= metric_end), default=len(text))
+        clause = text[left:right].strip(" ,;\t\n")
+        return clause or text.strip()
+
+    @classmethod
+    def _quantitative_metric_owner_for_occurrence(cls, sentence, match, constructs):
+        """Resolve a single standardized estimate to a frozen path owner."""
+        clause = cls._quantitative_metric_local_clause(sentence, match.start(), match.end())
+        roles = cls._quantitative_construct_roles_in_text(clause, constructs)
+        folded = cls._normalize_quantitative_construct_surface(clause)
+        has_indirect = bool(re.search(r"\bindirect\b", folded))
+        has_direct = bool(re.search(r"\b(?:direct|residual direct)\b", folded))
+
+        # Specific semantic labels win only when the construct frame is compatible.
+        if has_indirect and {"predictor", "outcome"}.issubset(roles):
+            return "indirect", clause
+        if has_direct and {"predictor", "outcome"}.issubset(roles):
+            return "direct", clause
+        if roles == {"predictor", "mediator"}:
+            return "a", clause
+        if roles == {"mediator", "outcome"}:
+            return "b", clause
+        if roles == {"predictor", "outcome"} and has_direct:
+            return "direct", clause
+        # A three-construct clause without an explicit direct/indirect relation is
+        # genuinely ambiguous and must not be guessed into a/b ownership.
+        return None, clause
+
+    @classmethod
+    def _strict_standardized_metric_occurrences(cls, sentence, constructs, results):
+        """Yield clause-bound owners for each beta/standardized-estimate occurrence."""
+        regex = re.compile(r"(?i)((?:β|standardized\s+estimate)\s*(?:=|:)?\s*)([-+]?\d+(?:\.\d+)?)")
+        expected = {key: results.get(key) for key in ("a", "b", "direct", "indirect")}
+        for match in regex.finditer(str(sentence or "")):
+            owner, clause = cls._quantitative_metric_owner_for_occurrence(sentence, match, constructs)
+            yield match, owner, expected.get(owner) if owner else None, clause
+
     @classmethod
     def inspect_quantitative_study_fact_contract(cls, text, metadata, section_name=""):
         """Pure AMJ quantitative Evidence Ledger inspection; never rewrites prose."""
@@ -1569,26 +1685,31 @@ Keywords: {keywords}"""
                     construct = str(constructs.get(role) or "")
                     if construct and results.get(key) is not None:
                         add_metric_violations(sentence, rf"(R(?:²|\^2)\s*(?:for|of)?\s*{re.escape(construct)}\s*(?:=|:)?\s*)([-+]?\d+(?:\.\d+)?)", results.get(key), label=key)
-                lower = sentence.casefold()
-                selected = None
-                specs = [
-                    ("indirect", results.get("indirect"), [constructs.get("predictor"), constructs.get("mediator"), constructs.get("outcome")]),
-                    ("direct", results.get("direct"), [constructs.get("predictor"), constructs.get("outcome")]),
-                    ("a", results.get("a"), [constructs.get("predictor"), constructs.get("mediator")]),
-                    ("b", results.get("b"), [constructs.get("mediator"), constructs.get("outcome")]),
-                ]
-                if "indirect" in lower and all(str(x or "").casefold() in lower for x in specs[0][2] if x):
-                    selected = specs[0]
-                elif f"controlling {str(constructs.get('mediator') or '').casefold()}" in lower and str(constructs.get("predictor") or "").casefold() in lower and str(constructs.get("outcome") or "").casefold() in lower:
-                    selected = specs[1]
-                elif f"controlling {str(constructs.get('predictor') or '').casefold()}" in lower and str(constructs.get("mediator") or "").casefold() in lower and str(constructs.get("outcome") or "").casefold() in lower:
-                    selected = specs[3]
-                elif str(constructs.get("predictor") or "").casefold() in lower and str(constructs.get("mediator") or "").casefold() in lower and str(constructs.get("outcome") or "").casefold() not in lower:
-                    selected = specs[2]
-                elif str(constructs.get("mediator") or "").casefold() in lower and str(constructs.get("outcome") or "").casefold() in lower and str(constructs.get("predictor") or "").casefold() not in lower:
-                    selected = specs[3]
-                if selected and selected[1] is not None:
-                    add_metric_violations(sentence, r"((?:β|standardized\s+estimate)\s*(?:=|:)?\s*)([-+]?\d+(?:\.\d+)?)", selected[1], label=selected[0])
+                # R6-R14 clause-bound metric ownership: validate each occurrence
+                # against its own local construct relation, never one owner per sentence.
+                for metric_match, metric_owner, metric_expected, metric_clause in cls._strict_standardized_metric_occurrences(
+                    sentence, constructs, results
+                ):
+                    observed = metric_match.group(2)
+                    if metric_owner is None or metric_expected is None:
+                        violations.append({
+                            "type":"quantitative_metric_owner_unresolved",
+                            "observed":observed,
+                            "preview":str(metric_clause or sentence).strip()[:180],
+                            "reason":"The standardized estimate cannot be uniquely bound to a frozen a/b/direct/indirect construct relation.",
+                        })
+                        continue
+                    try:
+                        same = abs(float(observed) - float(metric_expected)) < 0.0006
+                    except Exception:
+                        same = False
+                    if not same:
+                        expected_text = f"{float(metric_expected):.3f}".rstrip("0").rstrip(".")
+                        violations.append({
+                            "type":"quantitative_metric_mismatch", "metric":metric_owner,
+                            "observed":observed, "expected":expected_text,
+                            "preview":str(metric_clause or sentence).strip()[:180],
+                        })
             elif not strict:
                 for label, expected in dict(uploaded.get("r2_by_label") or {}).items():
                     if label and label in sentence.casefold():
@@ -1743,26 +1864,30 @@ Keywords: {keywords}"""
                         metric_pattern = rf"(R(?:²|\^2)\s*(?:for|of)?\s*{re.escape(construct)}\s*(?:=|:)?\s*)([-+]?\d+(?:\.\d+)?)"
                         replace_local_metric(metric_pattern, results.get(key), label=key)
 
-                lower = revised.casefold()
-                selected = None
-                specs = [
-                    ("indirect", results.get("indirect"), [constructs.get("predictor"), constructs.get("mediator"), constructs.get("outcome")]),
-                    ("direct", results.get("direct"), [constructs.get("predictor"), constructs.get("outcome")]),
-                    ("a", results.get("a"), [constructs.get("predictor"), constructs.get("mediator")]),
-                    ("b", results.get("b"), [constructs.get("mediator"), constructs.get("outcome")]),
-                ]
-                if "indirect" in lower and all(str(x or "").casefold() in lower for x in specs[0][2] if x):
-                    selected = specs[0]
-                elif f"controlling {str(constructs.get('mediator') or '').casefold()}" in lower and str(constructs.get("predictor") or "").casefold() in lower and str(constructs.get("outcome") or "").casefold() in lower:
-                    selected = specs[1]
-                elif f"controlling {str(constructs.get('predictor') or '').casefold()}" in lower and str(constructs.get("mediator") or "").casefold() in lower and str(constructs.get("outcome") or "").casefold() in lower:
-                    selected = specs[3]
-                elif str(constructs.get("predictor") or "").casefold() in lower and str(constructs.get("mediator") or "").casefold() in lower and str(constructs.get("outcome") or "").casefold() not in lower:
-                    selected = specs[2]
-                elif str(constructs.get("mediator") or "").casefold() in lower and str(constructs.get("outcome") or "").casefold() in lower and str(constructs.get("predictor") or "").casefold() not in lower:
-                    selected = specs[3]
-                if selected and selected[1] is not None:
-                    replace_local_metric(r"((?:β|standardized\s+estimate)\s*(?:=|:)?\s*)([-+]?\d+(?:\.\d+)?)", selected[1], label=selected[0])
+                # R6-R14 deterministic repair is also occurrence-local.  Never
+                # rewrite every metric in a sentence to one selected path value.
+                metric_replacements = []
+                for metric_match, metric_owner, metric_expected, metric_clause in cls._strict_standardized_metric_occurrences(
+                    revised, constructs, results
+                ):
+                    if metric_owner is None or metric_expected is None:
+                        continue
+                    observed = metric_match.group(2)
+                    try:
+                        same = abs(float(observed) - float(metric_expected)) < 0.0006
+                    except Exception:
+                        same = False
+                    if same:
+                        continue
+                    expected_text = f"{float(metric_expected):.3f}".rstrip("0").rstrip(".")
+                    diagnostics.append({
+                        "type":"quantitative_metric_repaired", "metric":metric_owner,
+                        "observed":observed, "expected":expected_text,
+                        "preview":str(metric_clause or revised).strip()[:180],
+                    })
+                    metric_replacements.append((metric_match.start(2), metric_match.end(2), expected_text))
+                for metric_start, metric_end, replacement in sorted(metric_replacements, reverse=True):
+                    revised = revised[:metric_start] + replacement + revised[metric_end:]
             elif not strict:
                 r2_map = dict(uploaded.get("r2_by_label") or {})
                 for label, expected in r2_map.items():

task_executor.py

@@ -128,13 +128,18 @@ def _is_recoverable_generation_failure(exc: Exception) -> bool:
     """Classify only post-claim execution failures.
 
     This deliberately avoids importing the generation pipeline at module import
-    time.  DeepSeek exception class names are stable public names inside this
-    project and are inspected only after claim/bootstrap has succeeded.
+    time. Provider/model exception class names are inspected only after
+    claim/bootstrap has succeeded, so future provider adapters do not require
+    executor imports or vendor-specific branching.
     """
     if isinstance(exc, ExecutorApiError):
         return exc.status_code == 429 or exc.status_code >= 500
     class_name = exc.__class__.__name__
-    if class_name in {"DeepSeekAuthenticationError", "DeepSeekBalanceError", "DeepSeekRequestError"}:
+    if class_name in {
+        "DeepSeekAuthenticationError", "DeepSeekBalanceError", "DeepSeekRequestError",
+        "ModelAuthenticationError", "ModelBalanceError", "ModelRequestError",
+        "ModelProviderUnavailableError", "ModelGatewayError",
+    }:
         return False
     if isinstance(exc, (requests.exceptions.Timeout, requests.exceptions.ConnectionError)):
         return True