R14-TQ2-PQ1-R1 Claim-Anchored Citation Recovery + Chinese Final Display + Completion Download Navigation

app.py

@@ -273,6 +273,7 @@ for key, default in {
     "sp_task_recovery_initialized": False,
     "sp_last_ui_task_status": "",
     "sp_scroll_to_generation_action": False,
+    "sp_completed_download_scroll_task_id": "",
 }.items():
     if key not in st.session_state:
         st.session_state[key] = default
@@ -833,15 +834,77 @@ def _load_confirmed_checkpoint(task: dict) -> dict | None:
         return None
 
 
+_PREVIEW_UNNUMBERED_HEADINGS = {
+    "abstract", "keyword", "keywords", "references", "reference list",
+    "摘要", "关键词", "关键字", "参考文献",
+    "аннотация", "ключевое слово", "ключевые слова", "литература", "список литературы",
+    "аңдатпа", "түйіндеме", "түйін сөздер", "түйінді сөздер", "кілт сөздер",
+    "әдебиеттер", "пайдаланылған әдебиеттер",
+}
+_PREVIEW_UNNUMBERED_PREFIXES = ("appendix", "附录", "приложение", "қосымша")
+
+
+def _normalize_preview_display_text(value: str) -> str:
+    """Mirror the browser heading presentation for initial/terminal rerenders.
+
+    Live updates are normalized by the browser bridge. A terminal Streamlit
+    rerender used to fall back to raw Markdown, so completed pages could show
+    ``#`` markers or lose the Arabic numbering users saw during generation.
+    Keep one deterministic server-side equivalent for the initial/terminal DOM.
+    """
+    lines = str(value or "").replace("\r", "").split("\n")
+    heading_rows = []
+    for index, line in enumerate(lines):
+        match = re.match(r"^(#{1,3})\s+(.+?)\s*$", line)
+        if not match:
+            continue
+        title = re.sub(r"^\d+(?:\.\d+){0,2}\s+", "", match.group(2).strip())
+        heading_rows.append((index, len(match.group(1)), title))
+    if not heading_rows:
+        return "\n".join(lines)
+
+    def unnumbered(title: str) -> bool:
+        key = str(title or "").strip().casefold()
+        return key in _PREVIEW_UNNUMBERED_HEADINGS or any(key.startswith(prefix) for prefix in _PREVIEW_UNNUMBERED_PREFIXES)
+
+    has_front_matter = any(unnumbered(title) for _index, _level, title in heading_rows)
+    first_h1 = next((row for row in heading_rows if row[1] == 1), None)
+    counters = [0, 0, 0]
+    for index, level, title in heading_rows:
+        is_known_unnumbered = unnumbered(title)
+        is_title = bool(has_front_matter and first_h1 and index == first_h1[0] and not is_known_unnumbered)
+        if is_known_unnumbered or is_title:
+            lines[index] = title
+            continue
+        if level == 1:
+            counters[0] += 1
+            counters[1] = counters[2] = 0
+            lines[index] = f"{counters[0]} {title}"
+        elif level == 2:
+            if counters[0] == 0:
+                counters[0] = 1
+            counters[1] += 1
+            counters[2] = 0
+            lines[index] = f"{counters[0]}.{counters[1]} {title}"
+        else:
+            if counters[0] == 0:
+                counters[0] = 1
+            if counters[1] == 0:
+                counters[1] = 1
+            counters[2] += 1
+            lines[index] = f"{counters[0]}.{counters[1]}.{counters[2]} {title}"
+    return "\n".join(lines)
+
+
 def _render_checkpoint_preview(task: dict, lang_code: str) -> None:
     """Render stable bilingual DOM targets; browser mutates them in place."""
     checkpoint = _load_confirmed_checkpoint(task)
     english = str((checkpoint or {}).get("full_draft_en") or "").strip()
     target = str((checkpoint or {}).get("full_draft_translated") or "").strip()
-    english_initial = english
+    english_initial = _normalize_preview_display_text(english)
     english_status_initial = "" if english else tr(lang_code, "draft_preparing")
     english_status_display = "none" if english else "block"
-    target_initial = target if target else tr(lang_code, "translation_waiting")
+    target_initial = _normalize_preview_display_text(target) if target else tr(lang_code, "translation_waiting")
     english_placeholder = "0" if english else "1"
     target_placeholder = "0" if target else "1"
     left, right = st.columns([1, 1], gap="medium")
@@ -871,6 +934,35 @@ def _render_checkpoint_preview(task: dict, lang_code: str) -> None:
     st.markdown("<style>@keyframes spBlink { 0%,49% {opacity:1} 50%,100% {opacity:0} }</style>", unsafe_allow_html=True)
 
 
+def _scroll_to_completed_download_once(task_id: str) -> None:
+    """Move the page to the existing download area once per completed task."""
+    task_id = str(task_id or "").strip()
+    if not task_id or st.session_state.get("sp_completed_download_scroll_task_id") == task_id:
+        return
+    st.session_state["sp_completed_download_scroll_task_id"] = task_id
+    components.html(
+        f"""
+        <script>
+        (() => {{
+          const parentDocument = window.parent.document;
+          const expectedTaskId = {json.dumps(task_id)};
+          let done = false;
+          const locate = () => {{
+            if (done) return;
+            const target = parentDocument.getElementById('sp-completed-download-anchor');
+            if (!target || target.dataset.spTaskId !== expectedTaskId) return;
+            done = true;
+            target.scrollIntoView({{behavior:'smooth', block:'center'}});
+          }};
+          [0, 60, 140, 300, 650, 1000].forEach(delay => window.setTimeout(locate, delay));
+        }})();
+        </script>
+        """,
+        height=0,
+        width=0,
+    )
+
+
 def _render_task_status_once(lang_code: str) -> None:
     task = st.session_state.get("sp_generation_task") or {}
     task_id = str(task.get("task_id") or "").strip()
@@ -902,8 +994,13 @@ def _render_task_status_once(lang_code: str) -> None:
     elif status == "completed":
         output_path = _task_output_path(task)
         if output_path and output_path.is_file():
+            st.markdown(
+                f"<div id='sp-completed-download-anchor' data-sp-task-id='{html.escape(task_id, quote=True)}'></div>",
+                unsafe_allow_html=True,
+            )
             st.success(tr(lang_code, "success"))
             st.download_button(label=tr(lang_code, "download"), data=output_path.read_bytes(), file_name=output_path.name, mime="application/zip")
+            _scroll_to_completed_download_once(task_id)
         else:
             st.warning("The task completed, but the local output file is unavailable after runtime replacement.")
     elif status == "failed":

core/generation_runner.py

@@ -65,6 +65,37 @@ def _canonical_request_hash(request_data: dict[str, Any]) -> str:
     return hashlib.sha256(encoded).hexdigest()
 
 
+def _normalize_target_manuscript_typography(text: str, target_lang: str) -> str:
+    """Apply only deterministic language-local typography after semantic QA.
+
+    R14-TQ2-PQ1-R1 fixes English-style spaces around Chinese full-width
+    punctuation without touching Russian/Kazakh spacing, references, semantic
+    content, or code-fenced material. This runs only after the target manuscript
+    has passed translation QA; it is presentation normalization, not translation.
+    """
+    value = str(text or "")
+    language = str(target_lang or "")
+    if "chinese" not in language.casefold() and "中文" not in language:
+        return value
+    value = value.replace("\r\n", "\n").replace("\r", "\n")
+    lines = value.split("\n")
+    normalized = []
+    in_fence = False
+    for line in lines:
+        stripped = line.lstrip()
+        if stripped.startswith("```"):
+            in_fence = not in_fence
+            normalized.append(line)
+            continue
+        if in_fence:
+            normalized.append(line)
+            continue
+        current = re.sub(r"[ \t]+([，。！？；：])", r"\1", line)
+        current = re.sub(r"([，。！？；：])[ \t]+(?=\S)", r"\1", current)
+        normalized.append(current)
+    return "\n".join(normalized)
+
+
 class _OrderedTranslationWorker:
     """One daemon worker owned by the headless Executor process.
 
@@ -2088,8 +2119,9 @@ class GenerationRunner:
                 )
             else:
                 citation_rule = (
-                    "Use the citation-first claim-evidence plan below. Every listed item has already been assigned to this unit on evidence relevance: use each assigned item exactly once unless it would contradict the frozen research evidence. "
-                    "For each item, write one distinct claim no broader than the supplied evidence and attach exactly its assigned [CITE-XX] tag. "
+                    "Use the citation-first claim-evidence plan below as bounded evidence options, not as a claim quota. "
+                    "Do not create a new claim merely to consume an assigned citation. Use a source only when it directly supports a claim independently required by the frozen research logic, section role, or already established manuscript argument; omit any item that would introduce another application domain or mutate the study's facts. "
+                    "When a source is used, keep the claim no broader than the supplied evidence and attach exactly its assigned [CITE-XX] tag. "
                     "Never stack sources, substitute tags, or use literature as evidence for this study's own facts.\n"
                     f"<CLAIM_EVIDENCE_PLAN>\n{claim_plan_text}\n</CLAIM_EVIDENCE_PLAN>"
                 )
@@ -2301,19 +2333,21 @@ Output only final academic prose. Do not report the word count."""
                             planned_items.append(recovery_item)
                             planned_tags_for_unit.add(tag)
                     citation_plan[display_name] = planned_items
-                    supplemental_raw = agent.build_citation_recovery_paragraph(
-                        recovery_items[:needed], section_name=display_name, section_context=en_resolved
+                    # R14-TQ2-PQ1-R1: recovery may attach evidence only to
+                    # an already-written claim. It is never authorized to create a
+                    # supplemental paragraph from a source merely to satisfy citation
+                    # survival. If no existing claim can be validated, leave prose
+                    # unchanged and let the literature-sufficiency Gate fail closed.
+                    recovered = agent.recover_citations_on_existing_claims(
+                        en_resolved,
+                        recovery_items[:needed],
+                        section_name=display_name,
+                        needed=needed,
                     )
-                    if supplemental_raw:
-                        supplemental_resolved = agent.audit_and_resolve_citations(
-                            supplemental_raw,
-                            section_name=f"{display_name} — citation recovery",
-                            quarantine=False,
-                        )
-                        if supplemental_resolved.strip():
-                            en_resolved = en_resolved.rstrip() + "\n\n" + supplemental_resolved.strip()
-                        used_after = set(agent.used_citations)
-                        survived = used_after - used_before
+                    if recovered != en_resolved:
+                        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:
@@ -2555,6 +2589,9 @@ Output only final academic prose. Do not report the word count."""
             full_draft_translated += (
                 f"\n\n# {agent._localized_reference_heading(target_lang)}\n" + reference_tail.strip()
             )
+            full_draft_translated = _normalize_target_manuscript_typography(
+                full_draft_translated, target_lang
+            )
             agent.validate_translation_alignment(full_draft_en, full_draft_translated)
             self._publish_target_preview(
                 full_draft_translated, 'translation_complete', force=True, complete=True
@@ -2570,6 +2607,13 @@ Output only final academic prose. Do not report the word count."""
             )
             self._checkpoint("translation_complete", state, 96)
 
+        normalized_target = _normalize_target_manuscript_typography(
+            full_draft_translated, target_lang
+        )
+        if normalized_target != full_draft_translated:
+            full_draft_translated = normalized_target
+            state["full_draft_translated"] = full_draft_translated
+
         existing_output = str(state.get("output_filename") or "").strip()
         if state.get("package_validated") and existing_output:
             existing_path = self.output_dir / os.path.basename(existing_output)

core/pipeline_agent.py

@@ -2546,6 +2546,18 @@ INPUT:
                 evidence = str((self.citation_map.get(tag) or {}).get('evidence') or '')
                 if len(self._citation_terms(claim) & self._citation_terms(evidence)) < 2:
                     continue
+                section_meta = next((item for item in sections if item['name'] == section), {})
+                section_context = ' '.join([
+                    str(topic or ''), section, str(section_meta.get('role') or ''),
+                ])
+                if not self._citation_recovery_item_relevant(
+                    {'claim': claim, 'evidence': evidence}, section, section_context
+                ):
+                    logging.info(
+                        'Citation planner rejected off-scope source: section=%s tag=%s',
+                        section, tag,
+                    )
+                    continue
                 used_tags.add(tag)
                 best.append({'tag': tag, 'section': section, 'claim': claim})
                 section_loads[section] += 1
@@ -2557,46 +2569,11 @@ INPUT:
                 batch_index // batch_size + 1, len(batch), accepted, len(best), target,
             )
 
-        # Evidence-derived recovery is deliberately local and conservative. It
-        # never invents a new empirical fact: the claim is copied from abstract
-        # evidence, and the section is selected by lexical relevance + capacity.
-        if len(best) < target:
-            loads = dict(section_loads)
-            for candidate in candidates:
-                if candidate['tag'] in used_tags:
-                    continue
-                evidence = str(candidate.get('evidence') or '')
-                abstract = evidence.split('Abstract evidence:', 1)[-1].strip() if 'Abstract evidence:' in evidence else ''
-                if len(abstract.split()) < 8:
-                    continue
-                sentence_parts = re.split(r'(?<=[.!?])\s+', abstract)
-                claim = next((part.strip() for part in sentence_parts if 8 <= len(part.split()) <= 55), '')
-                if not claim:
-                    words = abstract.split()
-                    if len(words) < 8:
-                        continue
-                    claim = ' '.join(words[:55]).rstrip(' ,;:') + '.'
-                evidence_terms = self._citation_terms(evidence)
-                ranked = []
-                for section in sections:
-                    name = section['name']
-                    if loads[name] >= capacities.get(name, target):
-                        continue
-                    section_terms = self._citation_terms(name + ' ' + section['role'])
-                    overlap = len(evidence_terms & section_terms)
-                    if overlap <= 0:
-                        continue
-                    load_ratio = loads[name] / max(1, capacities.get(name, 1))
-                    ranked.append((overlap, -load_ratio, section['target_words'], name))
-                if not ranked:
-                    continue
-                ranked.sort(reverse=True)
-                chosen = ranked[0][3]
-                best.append({'tag': candidate['tag'], 'section': chosen, 'claim': claim})
-                used_tags.add(candidate['tag'])
-                loads[chosen] += 1
-                if len(best) >= target:
-                    break
+        # R14-TQ2-PQ1-R1: citation planning is fail-closed rather than quota-driven.
+        # Do not manufacture a manuscript claim by copying an abstract sentence merely
+        # to fill the citation target. Unit-level contextual source selection below may
+        # still find genuinely relevant evidence; otherwise the adaptive literature
+        # sufficiency Gate fails before drafting instead of introducing another domain.
 
         plan = {item['name']: [] for item in sections}
         for row in best:
@@ -2647,7 +2624,11 @@ INPUT:
         overlap, distinctive = cls._citation_recovery_overlap(
             section_name, section_context, claim, evidence
         )
-        return distinctive >= 2 or (distinctive >= 1 and overlap >= 3)
+        # One distinctive token plus generic words (e.g. chatbot + research + users)
+        # is not enough to authorize a recovery source. Requiring two substantive
+        # overlaps is intentionally conservative: insufficient evidence must fail
+        # rather than import a different application domain.
+        return distinctive >= 2
 
     @classmethod
     def _best_contextual_evidence_claim(cls, evidence, section_name='', section_context=''):
@@ -2661,7 +2642,7 @@ INPUT:
             overlap, distinctive = cls._citation_recovery_overlap(
                 section_name, section_context, sentence, raw
             )
-            if distinctive >= 2 or (distinctive >= 1 and overlap >= 3):
+            if distinctive >= 2:
                 ranked.append((distinctive, overlap, -len(sentence.split()), sentence))
         if not ranked:
             return ''
@@ -2822,47 +2803,169 @@ INPUT:
         logging.info('Contextual citation JIT accepted: section=%s accepted=%s/%s', section_name, len(selected), needed)
         return selected
 
+    @staticmethod
+    def _citation_recovery_prose_signature(value):
+        """Canonical prose identity with only raw citation tags removed.
+
+        Recovery is allowed to add a citation to an existing claim, never to rewrite,
+        split, delete, or invent claim prose. Whitespace normalization is used only for
+        the comparison so an audit model cannot create a factual mutation silently.
+        """
+        stripped = re.sub(
+            r'\s*\[?CITE-\d+\]?\s*(?=[.!?。！？])', '', str(value or ''), flags=re.I
+        )
+        stripped = re.sub(r'\s*\[?CITE-\d+\]?\s*', ' ', stripped, flags=re.I)
+        return re.sub(r'\s+', ' ', stripped).strip()
+
+    @classmethod
+    def _citation_recovery_sentence_has_citation(cls, sentence):
+        value = str(sentence or '')
+        if re.search(r'CITE-\d+', value, re.I):
+            return True
+        return bool(re.search(
+            r"\((?=[^()\n]*[A-Za-zÀ-ÖØ-öø-ÿ'’.-]+(?:\s+(?:&\s+[A-Za-zÀ-ÖØ-öø-ÿ'’.-]+|et\s+al\.))?\s*,\s*(?:19|20)\d{2}[a-z]?\b)[^()\n]+\)",
+            value,
+            re.I,
+        ))
+
+    @staticmethod
+    def _append_raw_citation_to_sentence(sentence, tag):
+        raw = str(sentence or '')
+        trailing_match = re.search(r'(\s*)$', raw)
+        trailing = trailing_match.group(1) if trailing_match else ''
+        core = raw[:-len(trailing)] if trailing else raw
+        punctuation = ''
+        if core and core[-1] in '.!?。！？':
+            punctuation = core[-1]
+            core = core[:-1]
+        return f"{core.rstrip()} {tag}{punctuation}{trailing}"
+
+    def recover_citations_on_existing_claims(
+        self, text, items, *, section_name='', needed=1,
+    ):
+        """Attach recovery citations only to claims already present in the unit.
+
+        R14-TQ2-PQ1-R1 forbids citation-driven prose generation. A candidate source
+        must have at least two distinctive lexical overlaps with one citation-free
+        existing sentence. The proposed attachment is then passed through the same
+        semantic citation auditor. If that auditor rewrites/removes/splits any prose,
+        changes the selected tag set, or cannot validate technically, the whole
+        recovery proposal is rejected and the original manuscript text is retained.
+        The downstream literature-sufficiency Gate may then fail; unrelated filler is
+        never substituted merely to meet a citation quota.
+        """
+        value = str(text or '')
+        needed = max(0, int(needed or 0))
+        if not value.strip() or needed <= 0:
+            return value
+
+        candidates = []
+        for index, (start, end, sentence) in enumerate(self._sentence_spans(value)):
+            stripped = str(sentence or '').strip()
+            if not stripped or stripped.startswith('#') or self._citation_recovery_sentence_has_citation(stripped):
+                continue
+            sentence_terms = self._citation_terms(stripped)
+            if len(sentence_terms) < 4:
+                continue
+            candidates.append((index, start, end, sentence, sentence_terms))
+        if not candidates:
+            return value
+
+        ranked_assignments = []
+        occupied_sentences = set()
+        used_tags = set()
+        for item in items or []:
+            if not isinstance(item, dict):
+                continue
+            tag = str(item.get('tag') or '').strip()
+            claim = str(item.get('claim') or '').strip()
+            evidence = str(item.get('evidence') or '').strip()
+            if not tag or tag not in self.citation_map or tag in used_tags or not evidence:
+                continue
+            support_terms = self._citation_terms(f"{claim} {evidence}")
+            if not support_terms:
+                continue
+            scored = []
+            for candidate in candidates:
+                index, start, end, sentence, sentence_terms = candidate
+                if index in occupied_sentences:
+                    continue
+                overlap_terms = sentence_terms & support_terms
+                distinctive_terms = overlap_terms - self._CITATION_RECOVERY_GENERIC_TERMS
+                overlap = len(overlap_terms)
+                distinctive = len(distinctive_terms)
+                coverage = overlap / max(1, len(sentence_terms))
+                if distinctive < 2 or overlap < 2 or coverage < 0.08:
+                    continue
+                scored.append((distinctive, overlap, coverage, -index, candidate))
+            if not scored:
+                continue
+            scored.sort(reverse=True, key=lambda row: (row[0], row[1], row[2], row[3]))
+            _distinctive, _overlap, _coverage, _order, candidate = scored[0]
+            index, start, end, sentence, _terms = candidate
+            occupied_sentences.add(index)
+            used_tags.add(tag)
+            ranked_assignments.append((start, end, sentence, tag))
+            if len(ranked_assignments) >= needed:
+                break
+
+        if not ranked_assignments:
+            return value
+
+        proposed = value
+        for start, end, sentence, tag in sorted(ranked_assignments, key=lambda row: row[0], reverse=True):
+            replacement = self._append_raw_citation_to_sentence(sentence, tag)
+            proposed = proposed[:start] + replacement + proposed[end:]
+
+        expected_tags = {tag for _start, _end, _sentence, tag in ranked_assignments}
+        audit_len = len(self.citation_audit_log)
+        try:
+            audited = self.semantic_audit_claim_specific_citations(
+                proposed, section_name=f"{section_name} — claim-anchored citation recovery"
+            )
+        except PipelineCancelledError:
+            raise
+        except Exception as exc:
+            del self.citation_audit_log[audit_len:]
+            logging.warning(
+                'Claim-anchored citation recovery rejected after audit failure: section=%s error=%s',
+                section_name, self._safe_source_error(exc),
+            )
+            return value
+
+        actual_tags = {
+            f"[{tag.upper()}]" for tag in re.findall(r'CITE-\d+', audited, flags=re.I)
+        }
+        if (
+            actual_tags != expected_tags
+            or self._citation_recovery_prose_signature(audited) != self._citation_recovery_prose_signature(value)
+        ):
+            del self.citation_audit_log[audit_len:]
+            logging.warning(
+                'Claim-anchored citation recovery rejected prose/tag mutation: section=%s expected=%s actual=%s',
+                section_name, sorted(expected_tags), sorted(actual_tags),
+            )
+            return value
+
+        resolved = self.resolve_citations(audited, quarantine=False)
+        logging.info(
+            'Claim-anchored citation recovery accepted: section=%s attached=%s',
+            section_name, len(expected_tags),
+        )
+        return resolved
+
     def build_citation_recovery_paragraph(self, items, section_name='', section_context=''):
-        """Create one bounded literature paragraph from already planned evidence.
+        """Deprecated fail-closed compatibility shim.
 
-        This is invoked only when semantic validation removed too many planned
-        citations from a unit. It never invents new sources or study facts.
+        Citation recovery is no longer authorized to create prose from a source or
+        abstract sentence. Call ``recover_citations_on_existing_claims`` instead.
         """
-        selected = [
-            item for item in (items or [])
-            if item.get('tag') and item.get('claim') and item.get('evidence')
-            and self._citation_recovery_item_relevant(item, section_name, section_context)
-        ][:5]
-        if not selected:
-            return ''
-        plan_text = self.format_claim_evidence_plan(selected)
-        expected = [str(item['tag']) for item in selected]
-        prompt = f"""Write ONE cohesive top-journal literature paragraph for the named manuscript unit using ONLY the planned claim-evidence items below.
-Rules:
-1. Use every assigned [CITE-XX] tag exactly once, attached only to its own directly supported claim.
-2. Do not broaden a claim beyond its evidence and do not add any study-specific fact, statistic, setting, result, quotation, hypothesis, or new source.
-3. Do not stack citations. Keep each source's claim in a distinct sentence or clause.
-4. Avoid generic literature-listing prose and contribution-counting templates; connect the claims through one clear theoretical point relevant to the unit.
-5. Output only the paragraph, no heading or commentary.
-SECTION: {section_name}
-<CLAIM_EVIDENCE_PLAN>
-{plan_text}
-</CLAIM_EVIDENCE_PLAN>"""
-        raw = self.call_deepseek(
-            'You are a precise management-journal evidence integrator.',
-            prompt,
-            max_tokens=1400,
-            temp=0.1,
-            model_role='writing',
-            thinking=False,
-            allow_fallback=False,
-        ).strip()
-        actual = Counter(re.findall(r'\[CITE-\d+\]', raw, re.I))
-        expected_counter = Counter(expected)
-        if actual != expected_counter:
-            logging.warning('Citation recovery paragraph model output rejected; using evidence-plan fallback: section=%s', section_name)
-            raw = ' '.join(f"{str(item['claim']).rstrip('.')} {item['tag']}." for item in selected)
-        return raw.strip()
+        if items:
+            logging.warning(
+                'Citation recovery paragraph suppressed by claim-anchored policy: section=%s items=%s',
+                section_name, len(items),
+            )
+        return ''
 
     def _candidate_citation_tags(self, sentence, required_tags, limit):
         valid_required = [