R14-TQ2-PQ1-R2 Top-Level Claim Evidence Sufficiency + Study-Owned Boundary + Four-Language Failure Localization

app.py

@@ -1004,13 +1004,30 @@ def _render_task_status_once(lang_code: str) -> None:
         else:
             st.warning("The task completed, but the local output file is unavailable after runtime replacement.")
     elif status == "failed":
-        st.error(str(task.get("safe_error_detail") or task.get("safe_error_code") or tr(lang_code, "node_error")))
+        error_message, translation_note = _localized_terminal_task_error(task, lang_code)
+        st.error(error_message)
+        if translation_note:
+            st.warning(translation_note)
     elif status == "cancelled":
         detail = str(task.get("safe_error_detail") or "")
         if detail:
             st.warning(detail)
 
 
+def _localized_terminal_task_error(task: dict, lang_code: str) -> tuple[str, str]:
+    """Map stable business error codes to UI-language messages.
+
+    Engineering details remain in task/log state; the user-facing terminal view
+    does not expose a long English runtime exception in non-English interfaces.
+    """
+    code = str(task.get("safe_error_code") or "").strip()
+    detail = str(task.get("safe_error_detail") or "").strip()
+    raw = f"{code} {detail}"
+    if "E_LITERATURE_INSUFFICIENT" in raw:
+        return tr(lang_code, "literature_insufficient"), tr(lang_code, "upstream_translation_stopped")
+    return detail or code or tr(lang_code, "node_error"), ""
+
+
 def _inject_generation_action_scroll(mode: str) -> None:
     """Scroll immediately to the active generation action without a server wait."""
     target_id = "sp-generation-action-asq" if str(mode or "").lower() == "asq" else "sp-generation-action-amj"

core/generation_runner.py

@@ -1579,6 +1579,58 @@ class GenerationRunner:
             reserve_targets[display_name] = reserve
         return minimums, reserve_targets
 
+    @classmethod
+    def _top_level_citation_requirements(cls, tasks, mode: str):
+        """Aggregate citation authority by academic section, never by technical chunk.
+
+        ``Introduction (Part 1/2)`` and ``Introduction (Part 2/2)`` are generation
+        chunks, not separate scholarly evidence authorities.  Planning may remain
+        unit-local, but fatal literature sufficiency is evaluated on the canonical
+        top-level academic section.
+        """
+        allowed = cls._citation_eligible_section_ids(mode)
+        words_by_section = {}
+        for task in tasks or []:
+            section_id = str(task.get('section_id') or '')
+            if section_id not in allowed:
+                continue
+            words_by_section[section_id] = words_by_section.get(section_id, 0) + max(
+                1, int(task.get('target_words') or 1)
+            )
+        minimums = {}
+        reserve_targets = {}
+        for section_id, target_words in words_by_section.items():
+            base, words_per_source = CITATION_ROLE_RULES.get(section_id, (2, 240))
+            minimum = max(base, int(math.ceil(target_words / max(1, words_per_source))))
+            reserve = max(
+                minimum,
+                int(math.ceil(minimum / max(0.01, CITATION_SEMANTIC_SURVIVAL_RATIO))),
+            )
+            minimums[section_id] = minimum
+            reserve_targets[section_id] = reserve
+        return minimums, reserve_targets
+
+    @staticmethod
+    def _citation_unit_section_map(tasks):
+        return {
+            str(task.get('display_name') or ''): str(task.get('section_id') or '')
+            for task in (tasks or []) if str(task.get('display_name') or '').strip()
+        }
+
+    @staticmethod
+    def _top_level_unique_tag_counts(citation_plan, unit_section_map):
+        tags_by_section = {}
+        for unit_name, items in dict(citation_plan or {}).items():
+            section_id = str(unit_section_map.get(str(unit_name)) or '')
+            if not section_id:
+                continue
+            bucket = tags_by_section.setdefault(section_id, set())
+            for item in items or []:
+                tag = str((item or {}).get('tag') or '')
+                if tag:
+                    bucket.add(tag)
+        return {section_id: len(tags) for section_id, tags in tags_by_section.items()}
+
     @staticmethod
     def _adaptive_literature_candidate_target(target_words: int, agent) -> int:
         """Adaptive retrieval aspiration; never a final reference-count quota."""
@@ -1818,7 +1870,11 @@ class GenerationRunner:
             citation_minimums, citation_reserve_targets = self._adaptive_citation_requirements(
                 adaptive_structure, mode
             )
-            citation_plan_target = sum(citation_reserve_targets.values())
+            citation_top_level_minimums, citation_top_level_reserve_targets = self._top_level_citation_requirements(
+                adaptive_structure, mode
+            )
+            citation_unit_section_map = self._citation_unit_section_map(adaptive_structure)
+            citation_plan_target = sum(citation_top_level_reserve_targets.values())
             citation_plan = agent.build_claim_evidence_plan(
                 adaptive_structure, topic, synthesis_result, mode=mode,
                 target_unique=max(1, citation_plan_target),
@@ -1854,34 +1910,47 @@ class GenerationRunner:
                     if tag and tag not in planned_tags:
                         planned_items.append(item)
                         planned_tags.add(tag)
-                # External JIT is not used merely to hit the reserve target.
-                # It is triggered only when the unit remains below its actual
-                # evidence-demand minimum after exhausting already retrieved
-                # relevant literature.
-                minimum_shortfall = max(
-                    0, int(citation_minimums.get(display_name, 0)) - len(planned_items)
+                # Do not trigger external retrieval merely because a technical
+                # generation chunk is below a word-derived target.  Fatal evidence
+                # authority belongs to the canonical top-level academic section.
+
+            top_level_counts = self._top_level_unique_tag_counts(citation_plan, citation_unit_section_map)
+            for section_id, required in citation_top_level_minimums.items():
+                deficit = max(0, int(required) - int(top_level_counts.get(section_id, 0)))
+                if deficit <= 0:
+                    continue
+                section_units = [
+                    name for name, mapped in citation_unit_section_map.items() if mapped == section_id
+                ]
+                if not section_units:
+                    continue
+                primary_unit = section_units[0]
+                section_context = " ".join(
+                    self._citation_task_context(task_by_name.get(name, {}), research_logic_contract, synthesis_result)
+                    for name in section_units
                 )
-                if minimum_shortfall > 0:
-                    jit_items = agent.fetch_contextual_jit_recovery_items(
-                        topic=topic, section_name=display_name, section_context=section_context,
-                        needed=minimum_shortfall, excluded_tags=planned_tags,
-                    )
-                    for item in jit_items:
-                        tag = str(item.get("tag") or "")
-                        if tag and tag not in planned_tags:
-                            planned_items.append(item)
-                            planned_tags.add(tag)
+                jit_items = agent.fetch_contextual_jit_recovery_items(
+                    topic=topic, section_name=section_id, section_context=section_context,
+                    needed=deficit, excluded_tags=planned_tags,
+                )
+                planned_items = citation_plan.setdefault(primary_unit, [])
+                for item in jit_items:
+                    tag = str(item.get("tag") or "")
+                    if tag and tag not in planned_tags:
+                        planned_items.append(item)
+                        planned_tags.add(tag)
+                top_level_counts = self._top_level_unique_tag_counts(citation_plan, citation_unit_section_map)
 
             shortfalls = [
-                (name, len(citation_plan.get(name) or []), required)
-                for name, required in citation_minimums.items()
-                if len(citation_plan.get(name) or []) < required
+                (section_id, int(top_level_counts.get(section_id, 0)), required)
+                for section_id, required in citation_top_level_minimums.items()
+                if int(top_level_counts.get(section_id, 0)) < int(required)
             ]
             if shortfalls:
                 raise self._literature_insufficient_error(shortfalls)
             logging.info(
-                "Adaptive citation feasibility passed: minimum_total=%s reserve_target=%s planned_unique=%s units=%s",
-                sum(citation_minimums.values()), citation_plan_target, len(planned_tags), len(citation_minimums),
+                "Top-level citation feasibility passed: minimum_total=%s reserve_target=%s planned_unique=%s sections=%s",
+                sum(citation_top_level_minimums.values()), citation_plan_target, len(planned_tags), len(citation_top_level_minimums),
             )
             canonical_concept_ledger = self._build_canonical_concept_ledger(
                 mode, data_metadata, keywords=keywords, adaptive_structure=adaptive_structure,
@@ -1894,7 +1963,11 @@ class GenerationRunner:
                     "citation_plan": citation_plan,
                     "citation_minimums": citation_minimums,
                     "citation_reserve_targets": citation_reserve_targets,
+                    "citation_top_level_minimums": citation_top_level_minimums,
+                    "citation_top_level_reserve_targets": citation_top_level_reserve_targets,
+                    "citation_unit_section_map": citation_unit_section_map,
                     "citation_validated_tags_by_unit": {},
+                    "citation_required_claim_counts_by_unit": {},
                     "research_logic_contract": research_logic_contract,
                     "working_abstract": working_abstract,
                     "working_keywords": working_keywords,
@@ -1928,6 +2001,13 @@ class GenerationRunner:
         citation_plan = state.get("citation_plan") if isinstance(state.get("citation_plan"), dict) else {}
         citation_minimums = dict(state.get("citation_minimums") or {})
         citation_reserve_targets = dict(state.get("citation_reserve_targets") or {})
+        citation_top_level_minimums = dict(state.get("citation_top_level_minimums") or {})
+        citation_top_level_reserve_targets = dict(state.get("citation_top_level_reserve_targets") or {})
+        citation_unit_section_map = dict(state.get("citation_unit_section_map") or {})
+        citation_required_claim_counts_by_unit = {
+            str(name): int(count or 0)
+            for name, count in dict(state.get("citation_required_claim_counts_by_unit") or {}).items()
+        }
         citation_validated_tags_by_unit = {
             str(name): list(tags or [])
             for name, tags in dict(state.get("citation_validated_tags_by_unit") or {}).items()
@@ -1936,6 +2016,12 @@ class GenerationRunner:
             citation_minimums, citation_reserve_targets = self._adaptive_citation_requirements(
                 adaptive_structure, mode
             )
+        if not citation_top_level_minimums:
+            citation_top_level_minimums, citation_top_level_reserve_targets = self._top_level_citation_requirements(
+                adaptive_structure, mode
+            )
+        if not citation_unit_section_map:
+            citation_unit_section_map = self._citation_unit_section_map(adaptive_structure)
         translation_sections = dict(state.get('translation_sections') or {})
         translation_glossary = dict(state.get('translation_glossary') or {})
         canonical_concept_ledger = state.get('canonical_concept_ledger')
@@ -2050,18 +2136,23 @@ class GenerationRunner:
             self._progress(15, "citation_planning")
             citation_plan = agent.build_claim_evidence_plan(
                 adaptive_structure, topic, synthesis_result, mode=mode,
-                target_unique=max(1, sum(citation_reserve_targets.values())),
+                target_unique=max(1, sum(citation_top_level_reserve_targets.values())),
             )
+            top_level_counts = self._top_level_unique_tag_counts(citation_plan, citation_unit_section_map)
             shortfalls = [
-                (name, len(citation_plan.get(name) or []), required)
-                for name, required in citation_minimums.items()
-                if len(citation_plan.get(name) or []) < required
+                (section_id, int(top_level_counts.get(section_id, 0)), required)
+                for section_id, required in citation_top_level_minimums.items()
+                if int(top_level_counts.get(section_id, 0)) < int(required)
             ]
             if shortfalls:
                 raise self._literature_insufficient_error(shortfalls)
             state["citation_plan"] = citation_plan
             state["citation_minimums"] = citation_minimums
             state["citation_reserve_targets"] = citation_reserve_targets
+            state["citation_top_level_minimums"] = citation_top_level_minimums
+            state["citation_top_level_reserve_targets"] = citation_top_level_reserve_targets
+            state["citation_unit_section_map"] = citation_unit_section_map
+            state["citation_required_claim_counts_by_unit"] = citation_required_claim_counts_by_unit
             state["citation_validated_tags_by_unit"] = citation_validated_tags_by_unit
 
         quote_invocation_plan = (
@@ -2300,13 +2391,9 @@ Output only final academic prose. Do not report the word count."""
             used_after = set(agent.used_citations)
             survived = used_after - used_before
             if assigned_tag_list and not is_quarantined:
-                adaptive_minimum = max(1, int(citation_minimums.get(display_name, 1)))
                 required_survival = min(
                     len(assigned_tag_list),
-                    max(
-                        adaptive_minimum,
-                        int(math.ceil(len(assigned_tag_list) * CITATION_SEMANTIC_SURVIVAL_RATIO)),
-                    ),
+                    max(1, int(math.ceil(len(assigned_tag_list) * CITATION_SEMANTIC_SURVIVAL_RATIO))),
                 )
                 if len(survived) < required_survival:
                     missing_items = [
@@ -2348,14 +2435,18 @@ Output only final academic prose. Do not report the word count."""
                         en_resolved = recovered
                     used_after = set(agent.used_citations)
                     survived = used_after - used_before
-            if assigned_tag_list and not is_quarantined:
-                adaptive_minimum = max(1, int(citation_minimums.get(display_name, 1)))
-                if len(survived) < adaptive_minimum:
-                    raise self._literature_insufficient_error(
-                        [(display_name, len(survived), adaptive_minimum)]
+            if not is_quarantined and section_id in self._citation_eligible_section_ids(mode):
+                citation_required_claim_counts_by_unit[display_name] = agent.count_external_literature_claims(
+                    en_resolved, section_name=display_name
+                )
+                if assigned_tag_list:
+                    citation_validated_tags_by_unit[display_name] = sorted(
+                        survived, key=agent._citation_tag_number
                     )
-                citation_validated_tags_by_unit[display_name] = sorted(
-                    survived, key=agent._citation_tag_number
+                logging.info(
+                    "Top-level citation accumulation: unit=%s section=%s validated=%s external_claims=%s",
+                    display_name, citation_unit_section_map.get(display_name, section_id),
+                    len(survived), citation_required_claim_counts_by_unit[display_name],
                 )
             if mode == "asq" and section_id == "findings":
                 en_resolved = self._render_planned_qualitative_quotes(
@@ -2408,6 +2499,10 @@ Output only final academic prose. Do not report the word count."""
                     "citation_plan": citation_plan,
                     "citation_minimums": citation_minimums,
                     "citation_reserve_targets": citation_reserve_targets,
+                    "citation_top_level_minimums": citation_top_level_minimums,
+                    "citation_top_level_reserve_targets": citation_top_level_reserve_targets,
+                    "citation_unit_section_map": citation_unit_section_map,
+                    "citation_required_claim_counts_by_unit": citation_required_claim_counts_by_unit,
                     "citation_validated_tags_by_unit": citation_validated_tags_by_unit,
                     "agent_state": agent.export_state(),
                     "data_metadata": data_metadata,
@@ -2438,23 +2533,33 @@ Output only final academic prose. Do not report the word count."""
                     seen_refs.add(ref)
             if not references:
                 raise self._literature_insufficient_error([("final validated references", 0, 1)])
+            validated_by_top_level = {}
+            claims_by_top_level = {}
+            for unit_name, section_id in citation_unit_section_map.items():
+                if section_id not in citation_top_level_minimums:
+                    continue
+                validated_by_top_level.setdefault(section_id, set()).update(
+                    citation_validated_tags_by_unit.get(unit_name) or []
+                )
+                claims_by_top_level[section_id] = claims_by_top_level.get(section_id, 0) + int(
+                    citation_required_claim_counts_by_unit.get(unit_name, 0) or 0
+                )
             final_shortfalls = []
-            for name, minimum in citation_minimums.items():
-                validated_tags = set(citation_validated_tags_by_unit.get(name) or [])
-                if not validated_tags:
-                    validated_tags = {
-                        str(item.get("tag") or "")
-                        for item in (citation_plan.get(name) or [])
-                        if str(item.get("tag") or "") in agent.used_citations
-                    }
-                if len(validated_tags) < int(minimum):
-                    final_shortfalls.append((name, len(validated_tags), int(minimum)))
+            for section_id, planned_minimum in citation_top_level_minimums.items():
+                validated_tags = set(validated_by_top_level.get(section_id) or [])
+                external_claims = max(0, int(claims_by_top_level.get(section_id, 0)))
+                # Fatal authority is evidence need, not a word-count quota.  The
+                # top-level planning minimum is therefore capped by the number of
+                # externally-oriented claims that actually survived drafting.
+                required = min(int(planned_minimum), external_claims) if external_claims else 0
+                if len(validated_tags) < required:
+                    final_shortfalls.append((section_id, len(validated_tags), required))
             if final_shortfalls:
                 raise self._literature_insufficient_error(final_shortfalls)
             final_reference_count = len(references)
             logging.info(
-                "Adaptive citation final Gate passed: validated_references=%s units=%s",
-                final_reference_count, len(citation_minimums),
+                "Top-level claim-evidence final Gate passed: validated_references=%s sections=%s",
+                final_reference_count, len(citation_top_level_minimums),
             )
             full_draft_en = full_draft_en.rstrip() + "\n\n# References\n" + "\n\n".join(references)
             actual_words = self._english_count_for_target(full_draft_en)
@@ -2522,6 +2627,10 @@ Output only final academic prose. Do not report the word count."""
                     "citation_plan": citation_plan,
                     "citation_minimums": citation_minimums,
                     "citation_reserve_targets": citation_reserve_targets,
+                    "citation_top_level_minimums": citation_top_level_minimums,
+                    "citation_top_level_reserve_targets": citation_top_level_reserve_targets,
+                    "citation_unit_section_map": citation_unit_section_map,
+                    "citation_required_claim_counts_by_unit": citation_required_claim_counts_by_unit,
                     "citation_validated_tags_by_unit": citation_validated_tags_by_unit,
                     "quality_diagnostics": quality_diagnostics,
                     "english_finalized": True,

core/pipeline_agent.py

@@ -2828,6 +2828,67 @@ INPUT:
             re.I,
         ))
 
+    @staticmethod
+    def _citation_claim_provenance(sentence, section_name=''):
+        """Classify whether an existing sentence is eligible for external-literature recovery.
+
+        This is deliberately conservative and deterministic.  The recovery path may
+        only add evidence to externally-oriented claims; it must not attach a source
+        merely to satisfy a citation target when the sentence is owned by the current
+        study, reports the current study's results, states the authors' positioning,
+        or serves only as structure/transition.
+        """
+        text = re.sub(r'\s+', ' ', str(sentence or '')).strip()
+        lower = text.lower()
+        section = str(section_name or '').lower()
+        if not text:
+            return 'STRUCTURAL'
+        if re.match(r'^(?:h\d+[a-z]?\s*[:.\-]|hypothesis\s+\d+\b)', lower):
+            return 'HYPOTHESIS_STATEMENT'
+        if re.search(r'\b(?:we hypothesi[sz]e|we propose|we predict|we expect)\b', lower):
+            return 'HYPOTHESIS_STATEMENT'
+        if re.search(
+            r'\b(?:the present study|this study|our study|the current study|the present research|this research)\b',
+            lower,
+        ):
+            if re.search(r'\b(?:contribut|position|ask|research question|does not assume|focus|aim|seek|examine|investigat|test)\w*\b', lower):
+                return 'STUDY_POSITIONING'
+            return 'STUDY_OWNED_FACT'
+        if re.search(
+            r'\b(?:we collected|we recruited|we interviewed|we observed|we conducted|we analyzed|we analysed|'
+            r'we used|we employed|our sample|our data|our participants|sample consisted|participants included|'
+            r'data were collected|data was collected|to answer this question,? (?:we|the study))\b',
+            lower,
+        ):
+            return 'STUDY_OWNED_FACT'
+        if any(token in section for token in ('result', 'finding')) and re.search(
+            r'\b(?:we found|we find|our findings|our results|the results|the findings|coefficient|p\s*[<=>]|r\s*[²2]|β|beta)\b',
+            lower,
+        ):
+            return 'RESULT_OWNED_FACT'
+        if len(re.findall(r'[A-Za-z]{3,}', text)) < 4 and not re.search(r'[\u4e00-\u9fff\u0400-\u04ff]', text):
+            return 'STRUCTURAL'
+        return 'EXTERNAL_LITERATURE_CLAIM'
+
+    @classmethod
+    def _citation_recovery_eligible_claim(cls, sentence, section_name=''):
+        return cls._citation_claim_provenance(sentence, section_name) == 'EXTERNAL_LITERATURE_CLAIM'
+
+    @classmethod
+    def count_external_literature_claims(cls, text, section_name=''):
+        return sum(
+            1 for _start, _end, sentence in cls._sentence_spans(str(text or ''))
+            if cls._citation_recovery_eligible_claim(sentence, section_name)
+        )
+
+    @classmethod
+    def count_citation_recovery_eligible_claims(cls, text, section_name=''):
+        return sum(
+            1 for _start, _end, sentence in cls._sentence_spans(str(text or ''))
+            if cls._citation_recovery_eligible_claim(sentence, section_name)
+            and not cls._citation_recovery_sentence_has_citation(str(sentence or ''))
+        )
+
     @staticmethod
     def _append_raw_citation_to_sentence(sentence, tag):
         raw = str(sentence or '')
@@ -2864,6 +2925,12 @@ INPUT:
             stripped = str(sentence or '').strip()
             if not stripped or stripped.startswith('#') or self._citation_recovery_sentence_has_citation(stripped):
                 continue
+            if not self._citation_recovery_eligible_claim(stripped, section_name):
+                logging.info(
+                    'Claim-anchored citation recovery skipped non-literature claim: section=%s provenance=%s',
+                    section_name, self._citation_claim_provenance(stripped, section_name),
+                )
+                continue
             sentence_terms = self._citation_terms(stripped)
             if len(sentence_terms) < 4:
                 continue

i18n.py

@@ -305,6 +305,8 @@ TEXTS: dict[str, dict[str, str]] = {
         "word_count": "📊 本章节实际字数：{actual}（目标：{target}），累计偏差：{deviation:+d}",
         "translation_running": "⏳ 英文已完成，正在后台异步翻译……",
         "node_error": "🚨 节点异常已中止。",
+        "literature_insufficient": "当前高相关文献不足以直接支撑部分核心论断。系统没有使用无关文献凑数。请调整研究题目或关键词，或上传更直接相关的核心文献后重试。",
+        "upstream_translation_stopped": "英文母稿的证据检查未通过，后续翻译已停止；当前页面中已显示的译文不是完整论文。",
         "node_error_detail": "错误代码：{code}｜{error}｜系统已保存断点，可继续恢复。",
         "task_cancelled": "任务已取消，断点和临时文件已删除。",
         "task_start_failed": "无法启动论文任务：{error}",
@@ -481,6 +483,8 @@ TEXTS: dict[str, dict[str, str]] = {
         "word_count": "📊 Section word count: {actual} (target: {target}); cumulative deviation: {deviation:+d}",
         "translation_running": "⏳ English draft complete. Background translation is running…",
         "node_error": "🚨 The node stopped because of an error.",
+        "literature_insufficient": "The available high-relevance literature is insufficient to support some core manuscript claims. Unrelated sources were not used to fill a quota. Revise the research topic or keywords, or provide more directly relevant core literature, and try again.",
+        "upstream_translation_stopped": "The English source manuscript did not pass the evidence gate, so downstream translation stopped. Any translated text currently shown is incomplete and is not a final paper.",
         "node_error_detail": "Error code: {code} | {error} | A checkpoint has been saved and can be resumed.",
         "task_cancelled": "The task was cancelled. Its checkpoint and temporary files were deleted.",
         "task_start_failed": "The paper task could not be started: {error}",
@@ -657,6 +661,8 @@ TEXTS: dict[str, dict[str, str]] = {
         "word_count": "📊 Объём раздела: {actual} слов (цель: {target}); накопленное отклонение: {deviation:+d}",
         "translation_running": "⏳ Английский текст завершён. Выполняется фоновый перевод…",
         "node_error": "🚨 Выполнение узла остановлено из-за ошибки.",
+        "literature_insufficient": "Доступной высокорелевантной литературы недостаточно для прямой поддержки части ключевых утверждений рукописи. Система не использовала нерелевантные источники ради количества. Измените тему или ключевые слова либо добавьте более релевантные основные источники и повторите попытку.",
+        "upstream_translation_stopped": "Английская исходная рукопись не прошла проверку доказательной базы, поэтому дальнейший перевод остановлен. Уже показанный перевод неполный и не является окончательной статьёй.",
         "node_error_detail": "Код ошибки: {code} | {error} | Контрольная точка сохранена; работу можно продолжить.",
         "task_cancelled": "Задача отменена. Контрольная точка и временные файлы удалены.",
         "task_start_failed": "Не удалось запустить подготовку статьи: {error}",
@@ -833,6 +839,8 @@ TEXTS: dict[str, dict[str, str]] = {
         "word_count": "📊 Бөлім көлемі: {actual} сөз (мақсат: {target}); жиынтық ауытқу: {deviation:+d}",
         "translation_running": "⏳ Ағылшын мәтіні аяқталды. Фондық аударма орындалуда…",
         "node_error": "🚨 Қате салдарынан түйін тоқтатылды.",
+        "literature_insufficient": "Қолжетімді жоғары релевантты әдебиет қолжазбаның кейбір негізгі тұжырымдарын тікелей қолдауға жеткіліксіз. Жүйе санды толтыру үшін қатысы жоқ дереккөздерді пайдаланбады. Зерттеу тақырыбын немесе кілт сөздерді өзгертіңіз не тікелей релевантты негізгі әдебиетті қосып, қайта көріңіз.",
+        "upstream_translation_stopped": "Ағылшын тіліндегі бастапқы қолжазба дәлелдер тексерісінен өтпеді, сонд��қтан кейінгі аударма тоқтатылды. Қазір көрсетілген аударма толық емес және соңғы мақала болып саналмайды.",
         "node_error_detail": "Қате коды: {code} | {error} | Бақылау нүктесі сақталды; жұмысты жалғастыруға болады.",
         "task_cancelled": "Тапсырма тоқтатылды. Бақылау нүктесі мен уақытша файлдар жойылды.",
         "task_start_failed": "Мақала тапсырмасын бастау мүмкін болмады: {error}",