Step 4A-6-C-R3.2.8.3 Translation Semantic Anchor Working Final Abstract Fix

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+core/__pycache__/pipeline_agent.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text

__pycache__/desktop.ini

@@ -0,0 +1,2 @@
+[.ShellClassInfo]
+IconResource=C:\Program Files\Google\Drive File Stream\129.0.1.0\GoogleDriveFS.exe,27

core/__pycache__/desktop.ini

@@ -0,0 +1,2 @@
+[.ShellClassInfo]
+IconResource=C:\Program Files\Google\Drive File Stream\129.0.1.0\GoogleDriveFS.exe,27

core/__pycache__/pipeline_agent.cpython-313.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a58cec79f28771e880158bd36b2afd8c77ac1982a61db28ff832a962c41ed79c
+size 251613

core/generation_runner.py

@@ -224,6 +224,20 @@ class GenerationRunner:
         match = re.search(rf'(?m)^#\s+{re.escape(str(first_section_title))}\s*$', value)
         return value[:match.start()].strip() if match else ''
 
+    @staticmethod
+    def _replace_keywords(manuscript: str, keywords) -> str:
+        value = str(manuscript or '')
+        if isinstance(keywords, (list, tuple)):
+            rendered = ', '.join(str(item).strip() for item in keywords if str(item).strip())
+        else:
+            rendered = str(keywords or '').strip()
+        pattern = re.compile(r'(?ms)(^##\s+Keywords\s*$\n)(.*?)(?=^#\s+[^#].*?$|\Z)')
+        matches = list(pattern.finditer(value))
+        if len(matches) != 1:
+            raise RuntimeError(f'keywords_heading_count_invalid:{len(matches)}')
+        match = matches[0]
+        return value[:match.start()] + match.group(1) + rendered + '\n\n' + value[match.end():].lstrip('\n')
+
     @staticmethod
     def _section_is_complete(tasks, completed_display_names, section_key: str) -> bool:
         relevant = [
@@ -463,13 +477,29 @@ class GenerationRunner:
                 raise RuntimeError("research_logic_contract_missing")
             agent.global_memory["research_logic_contract"] = research_logic_contract
 
+            self._progress(14, "working_front_matter")
+            working_front = agent.generate_working_front_matter(
+                topic, keywords, research_logic_contract, synthesis_result,
+                data_evidence=user_data_md, mode=mode,
+            )
+            working_abstract = str(working_front.get("abstract") or "").strip()
+            working_keywords = list(working_front.get("keywords") or [])
+            if not working_abstract or not working_keywords:
+                raise RuntimeError("working_front_matter_missing")
+            agent.global_memory["working_abstract"] = working_abstract
+
             self._progress(14, "outline_planning")
             plan = agent.generate_outline(topic, keywords, mode=mode, data_metadata=data_metadata)
             en_topic = str(plan.get("en_topic", topic))
             structure = plan.get("structure", [])
-            # The final abstract is derived after Results/Findings validation;
-            # do not pre-commit the paper to an expected conclusion.
-            full_draft_en = f"# {en_topic}\n\n## Abstract\n\n## Keywords\n{keywords}\n\n"
+            full_draft_en = (
+                f"# {en_topic}\n\n## Abstract\n{working_abstract}\n\n"
+                f"## Keywords\n{', '.join(working_keywords)}\n\n"
+            )
+            # Publish the Working Abstract/Keywords immediately, before JIT and
+            # citation planning, so the user sees the manuscript anchor before
+            # Introduction while those longer planning stages continue.
+            self._publish_preview(full_draft_en, "working_front_matter", force=True)
             front_budget = max(180, int(APP_CONFIG.get("word_budget", {}).get("front_matter_words", 220)))
             body_target_words = max(1000, target_words - front_budget)
             adaptive_structure = agent.build_generation_tasks(structure, body_target_words, safe_chunk_words)
@@ -498,6 +528,9 @@ class GenerationRunner:
                     "adaptive_structure": adaptive_structure,
                     "citation_plan": citation_plan,
                     "research_logic_contract": research_logic_contract,
+                    "working_abstract": working_abstract,
+                    "working_keywords": working_keywords,
+                    "front_matter_phase": "working",
                     "body_target_words": body_target_words,
                     "full_draft_en": full_draft_en,
                     "full_draft_translated": "",
@@ -526,8 +559,62 @@ class GenerationRunner:
         citation_plan = state.get("citation_plan") if isinstance(state.get("citation_plan"), dict) else {}
         translation_sections = dict(state.get('translation_sections') or {})
         translation_glossary = dict(state.get('translation_glossary') or {})
+        working_abstract = str(state.get("working_abstract") or "").strip()
+        working_keywords = list(state.get("working_keywords") or [])
+        if working_abstract:
+            agent.global_memory["working_abstract"] = working_abstract
         if self._preview_target_text == '':
             self._preview_target_text = str(state.get('full_draft_translated') or '')
+
+        # Backward-compatible resume path for a pre-R3.2.8.3 checkpoint that has
+        # an outline but no Working Abstract yet. Generate it once, checkpoint it,
+        # and reuse it thereafter; never regenerate an unchanged anchor on resume.
+        if not working_abstract and not state.get("english_finalized"):
+            working_front = agent.generate_working_front_matter(
+                topic, keywords, research_logic_contract, synthesis_result,
+                data_evidence=user_data_md, mode=mode,
+            )
+            working_abstract = str(working_front.get("abstract") or "").strip()
+            working_keywords = list(working_front.get("keywords") or [])
+            if not working_abstract or not working_keywords:
+                raise RuntimeError("working_front_matter_missing")
+            agent.global_memory["working_abstract"] = working_abstract
+            full_draft_en = replace_abstract(full_draft_en, working_abstract)
+            full_draft_en = self._replace_keywords(full_draft_en, working_keywords)
+            state.update({
+                "working_abstract": working_abstract,
+                "working_keywords": working_keywords,
+                "front_matter_phase": "working",
+                "full_draft_en": full_draft_en,
+                "agent_state": agent.export_state(),
+            })
+            self._publish_preview(full_draft_en, "working_front_matter", force=True)
+            self._checkpoint("working_front_matter_ready", state, 15)
+
+        # Translate the QA-frozen Working front matter before Introduction. The
+        # same __front_matter__ record is hash-reused on resume and invalidated
+        # later when Final Abstract/Keywords replace the working front matter.
+        if working_abstract and not state.get("english_finalized"):
+            section_order_for_front = self._unique_top_level_sections(adaptive_structure)
+            if section_order_for_front:
+                working_front_source = self._extract_front_matter(full_draft_en, section_order_for_front[0][1])
+                translation_sections, translation_glossary = self._translate_frozen_unit(
+                    agent, unit_key='__front_matter__', unit_name='Working Front Matter',
+                    source_text=working_front_source, target_lang=target_lang,
+                    translation_sections=translation_sections, translation_glossary=translation_glossary,
+                    adaptive_structure=adaptive_structure, include_front=True,
+                )
+                working_target = self._assemble_partial_translation(
+                    translation_sections, adaptive_structure, include_front=True
+                )
+                state.update({
+                    "full_draft_en": full_draft_en,
+                    "full_draft_translated": working_target,
+                    "translation_sections": translation_sections,
+                    "translation_glossary": translation_glossary,
+                    "agent_state": agent.export_state(),
+                })
+                self._checkpoint("working_front_matter_translated", state, 16)
         if not citation_plan:
             self._progress(15, "citation_planning")
             citation_plan = agent.build_claim_evidence_plan(
@@ -653,6 +740,10 @@ Target length: {int(adjusted_target * min_ratio)}-{int(adjusted_target * max_rat
 <PROVISIONAL_RESEARCH_LOGIC>
 {research_logic_contract}
 </PROVISIONAL_RESEARCH_LOGIC>
+<WORKING_ABSTRACT_ANCHOR>
+{working_abstract}
+</WORKING_ABSTRACT_ANCHOR>
+ANCHOR PRECEDENCE: Frozen research evidence and the PROVISIONAL_RESEARCH_LOGIC override the Working Abstract if any tension appears. The Working Abstract is continuity guidance only and must never force a result.
 {memory_block}
 Literature synthesis: {synthesis_result}
 <FROZEN_RESEARCH_EVIDENCE>
@@ -751,9 +842,9 @@ Output only final academic prose. Do not report the word count."""
                     agent, unit_key=section_key, unit_name=sec_title, source_text=frozen_section,
                     target_lang=target_lang, translation_sections=translation_sections,
                     translation_glossary=translation_glossary, adaptive_structure=adaptive_structure,
-                    include_front=False,
+                    include_front=True,
                 )
-            partial_translation = self._assemble_partial_translation(translation_sections, adaptive_structure)
+            partial_translation = self._assemble_partial_translation(translation_sections, adaptive_structure, include_front=True)
             state.update(
                 {
                     "completed_sections": completed_sections,
@@ -772,10 +863,9 @@ Output only final academic prose. Do not report the word count."""
         if not state.get("english_finalized"):
             self._progress(91, "english_validation")
             full_draft_en = _clean_trailing_references(full_draft_en, ["Reference", "References", "Reference List"])
-            final_abstract = agent.generate_final_abstract(
-                topic, keywords, full_draft_en, data_evidence=user_data_md, mode=mode
-            )
-            full_draft_en = replace_abstract(full_draft_en, final_abstract)
+            # 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":
                 repeated_quotes = agent.find_repeated_qualitative_quotes(full_draft_en, data_metadata)
@@ -807,15 +897,54 @@ Output only final academic prose. Do not report the word count."""
             )
             agent.validate_manuscript_structure(body_only, adaptive_structure, translated=False)
             agent.enforce_resolved_claim_specific_citations(body_only)
+
+            # Body is now frozen. Generate both Final Abstract and Final Keywords
+            # from the completed manuscript/evidence, then replace the provisional
+            # front matter deterministically. No body rebalance may occur afterward.
+            self._progress(92, "final_front_matter")
+            final_front = agent.generate_final_front_matter(
+                topic, keywords, body_only, data_evidence=user_data_md, mode=mode
+            )
+            final_abstract = str(final_front.get("abstract") or "").strip()
+            final_keywords = list(final_front.get("keywords") or [])
+            if not final_abstract or not final_keywords:
+                raise RuntimeError("final_front_matter_missing")
+            full_draft_en = replace_abstract(full_draft_en, final_abstract)
+            full_draft_en = self._replace_keywords(full_draft_en, final_keywords)
+            body_only, _reference_tail = agent.validate_reference_tail(
+                full_draft_en, minimum_references=MIN_FINAL_REFERENCES
+            )
+            agent.validate_manuscript_structure(body_only, adaptive_structure, translated=False)
+            agent.enforce_resolved_claim_specific_citations(body_only)
             self._validate_target_length(full_draft_en, target_words)
+
+            # Final front matter has a different source hash from the Working
+            # front matter. Retranslate only __front_matter__; unchanged body
+            # translations are retained and reused.
+            section_order_for_front = self._unique_top_level_sections(adaptive_structure)
+            if section_order_for_front:
+                final_front_source = self._extract_front_matter(body_only, section_order_for_front[0][1])
+                translation_sections, translation_glossary = self._translate_frozen_unit(
+                    agent, unit_key='__front_matter__', unit_name='Final Front Matter',
+                    source_text=final_front_source, target_lang=target_lang,
+                    translation_sections=translation_sections, translation_glossary=translation_glossary,
+                    adaptive_structure=adaptive_structure, include_front=True,
+                )
+            partial_target = self._assemble_partial_translation(
+                translation_sections, adaptive_structure, include_front=True
+            )
             self._publish_preview(full_draft_en, "english_complete", force=True, complete=True)
             state.update(
                 {
                     "full_draft_en": full_draft_en,
-                    "full_draft_translated": self._assemble_partial_translation(translation_sections, adaptive_structure),
+                    "full_draft_translated": partial_target,
                     "translation_sections": translation_sections,
                     "translation_glossary": translation_glossary,
+                    "final_abstract": final_abstract,
+                    "final_keywords": final_keywords,
+                    "front_matter_phase": "final",
                     "english_finalized": True,
+                    "translation_complete": False,
                     "agent_state": agent.export_state(),
                 }
             )

core/pipeline_agent.py

@@ -1229,6 +1229,122 @@ Return a concise PROVISIONAL RESEARCH LOGIC CONTRACT in plain English prose. It
             model_role="reasoning", thinking=True, allow_fallback=False,
         )
 
+    @staticmethod
+    def _front_matter_keywords(value, minimum=4, maximum=6):
+        if isinstance(value, list):
+            raw = value
+        else:
+            raw = re.split(r'[,;\n]+', str(value or ''))
+        cleaned = []
+        for item in raw:
+            term = re.sub(r'^[\s\-•]+|[\s.;]+$', '', str(item or '')).strip()
+            if term and term.casefold() not in {existing.casefold() for existing in cleaned}:
+                cleaned.append(term)
+        if not minimum <= len(cleaned) <= maximum:
+            raise DeepSeekRequestError(
+                f'Front-matter keywords must contain {minimum}-{maximum} distinct terms; got {len(cleaned)}.'
+            )
+        return cleaned
+
+    @staticmethod
+    def _front_matter_has_citation(value):
+        text = str(value or '')
+        return bool(
+            re.search(r'\[?CITE-\d+\]?', text, flags=re.I)
+            or re.search(r'\([^()\n]*?(?:19|20)\d{2}[a-z]?[^()\n]*?\)', text, flags=re.I)
+        )
+
+    @classmethod
+    def _validate_working_abstract(cls, value):
+        text = re.sub(r'(?im)^#+\s*abstract\s*', '', str(value or '')).strip()
+        words = re.findall(r"\b[A-Za-z0-9]+(?:[-'][A-Za-z0-9]+)*\b", text)
+        if len(words) < 80 or len(words) > 180:
+            raise DeepSeekRequestError(
+                f'Working Abstract must contain 80-180 English words; got {len(words)}.'
+            )
+        if cls._front_matter_has_citation(text):
+            raise DeepSeekRequestError('Working Abstract must not contain citations.')
+        forbidden = (
+            r'\bwe\s+(?:find|found|show|demonstrate|observe|establish)\b',
+            r'\b(?:results?|findings?)\s+(?:show|indicate|reveal|demonstrate|confirm|support)\b',
+            r'\b(?:supported|rejected)\s+(?:H\d+|hypothes)',
+            r'\bstatistically\s+significant\b',
+            r'(?:β|R²|χ²|ΔR²)\s*(?:=|<|>|≤|≥)',
+            r'\bp\s*(?:=|<|>|≤|≥)\s*(?:\d|\.)',
+        )
+        if any(re.search(pattern, text, flags=re.I) for pattern in forbidden):
+            raise DeepSeekRequestError('Working Abstract asserted a result that is not yet frozen.')
+        return text
+
+    def generate_working_front_matter(
+        self, topic, keywords, research_logic_contract, synthesis_result, data_evidence='', mode='amj'
+    ):
+        """Create a provisional visible abstract/keyword anchor without prewriting results."""
+        evidence = self._truncate_context(str(data_evidence or ''), 3500)
+        logic = self._truncate_context(str(research_logic_contract or ''), 3500)
+        synthesis = self._truncate_context(str(synthesis_result or ''), 3500)
+        prompt = f"""Create WORKING front matter for an empirical {str(mode).upper()}-oriented manuscript before body drafting.
+Return JSON only: {{\"abstract\":\"...\",\"keywords\":[\"...\"]}}.
+The Working Abstract must be 120-180 English words, have no citations, and function only as a continuity anchor. It may state the research problem, theoretical tension, focal concepts, question/hypothesis architecture, design or method class, and intended contribution domain. It MUST NOT state coefficients, p-values, fit statistics, sample statistics unless already indispensable to define the design, supported/unsupported hypotheses, result direction, substantive findings, or a conclusion that has not yet been frozen. Do not predict findings.
+Return 4-6 concise academic keywords. User keywords are seeds, not an authoritative final list.
+TOPIC: {topic}
+USER KEYWORD SEEDS: {keywords}
+<PROVISIONAL_RESEARCH_LOGIC>
+{logic}
+</PROVISIONAL_RESEARCH_LOGIC>
+<LITERATURE_SYNTHESIS>
+{synthesis}
+</LITERATURE_SYNTHESIS>
+<FROZEN_RESEARCH_EVIDENCE>
+{evidence}
+</FROZEN_RESEARCH_EVIDENCE>"""
+        response = self.call_deepseek(
+            'You are a senior management-journal editor creating provisional front matter without anticipating results.',
+            prompt, max_tokens=1100, temp=0.0, model_role='writing', thinking=False, allow_fallback=False,
+        )
+        parsed = self._extract_json_from_text(response)
+        if not isinstance(parsed, dict):
+            raise DeepSeekRequestError('Working front matter was not valid JSON.')
+        abstract = self._validate_working_abstract(parsed.get('abstract'))
+        working_keywords = self._front_matter_keywords(parsed.get('keywords'))
+        return {'abstract': abstract, 'keywords': working_keywords}
+
+    def generate_final_front_matter(self, topic, keywords, manuscript, data_evidence='', mode='amj'):
+        """Generate final Abstract + Keywords only from the frozen completed body/evidence."""
+        evidence = self._truncate_context(str(data_evidence or ''), 5000)
+        body = self._abstract_manuscript_context(manuscript, 18000)
+        prompt = f"""Write FINAL English front matter for this completed {str(mode).upper()} manuscript.
+Return JSON only: {{\"abstract\":\"...\",\"keywords\":[\"...\"]}}.
+The Abstract must be no more than 200 words, use no citations, and accurately state the research problem, validated design, main frozen finding(s), and contribution. Include only the minimum numerical evidence required; do not list coefficients, p-values, and fit statistics unless one value is indispensable. Do not infer beyond the frozen evidence or completed manuscript.
+Return 4-6 concise final academic keywords derived from the completed manuscript. User keyword seeds are advisory only.
+TOPIC: {topic}
+USER KEYWORD SEEDS: {keywords}
+<FROZEN_RESEARCH_EVIDENCE>
+{evidence}
+</FROZEN_RESEARCH_EVIDENCE>
+<COMPLETED_FROZEN_MANUSCRIPT>
+{body}
+</COMPLETED_FROZEN_MANUSCRIPT>"""
+        response = self.call_deepseek(
+            'You are a senior journal editor finalizing front matter from frozen manuscript evidence.',
+            prompt, max_tokens=1200, temp=0.0, model_role='writing', thinking=False, allow_fallback=False,
+        )
+        parsed = self._extract_json_from_text(response)
+        if not isinstance(parsed, dict):
+            raise DeepSeekRequestError('Final front matter was not valid JSON.')
+        abstract = re.sub(r'(?im)^#+\s*abstract\s*', '', str(parsed.get('abstract') or '')).strip()
+        if self._front_matter_has_citation(abstract):
+            raise DeepSeekRequestError('Final Abstract must not contain citations.')
+        abstract = self.polish_academic_section(abstract, 'Abstract', abstract=True, mode=mode)
+        if self._front_matter_has_citation(abstract):
+            raise DeepSeekRequestError('Final Abstract revision introduced a citation.')
+        max_words = max(80, int(APP_CONFIG.get('manuscript_quality', {}).get('abstract_max_words', 200)))
+        abstract = self._trim_at_sentence_boundary(abstract, max_words)
+        if len(re.findall(r"\b[A-Za-z0-9]+(?:[-'][A-Za-z0-9]+)*\b", abstract)) < 80:
+            raise DeepSeekRequestError('Final Abstract is too short after validation.')
+        final_keywords = self._front_matter_keywords(parsed.get('keywords'))
+        return {'abstract': abstract, 'keywords': final_keywords}
+
     # Backward-compatible name retained for old checkpoints/tests.
     def stream_generate_anchors(self, topic, keywords, synthesis_result, refs_text, data_evidence="", mode="amj"):
         return self.stream_generate_research_logic(
@@ -3176,18 +3292,10 @@ Output only the revised Discussion body, without the '# Discussion' heading."""
         return self._truncate_context(combined, max_tokens)
 
     def generate_final_abstract(self, topic, keywords, manuscript, data_evidence='', mode='amj'):
-        evidence = self._truncate_context(str(data_evidence or ''), 5000)
-        body = self._abstract_manuscript_context(manuscript, 18000)
-        prompt = f"""Write the final English abstract for this completed {mode.upper()} manuscript. Maximum 200 words. State the research problem, design, main finding, and contribution. Use no citations. Include only the minimum numerical evidence required; do not list coefficients, p-values, and fit statistics unless one value is indispensable. Use concise, accurate, rigorous academic language. Do not use metaphors, analogies, rhetorical questions, promotional language, formulaic transitions, or AI-related meta-commentary. Output only the abstract.\nTOPIC: {topic}\nKEYWORDS: {keywords}\nFROZEN EVIDENCE:\n{evidence}\nCOMPLETED MANUSCRIPT:\n{body}"""
-        abstract = self.call_deepseek(
-            'You are a senior journal editor.', prompt, max_tokens=900, temp=0.1,
-            model_role='writing', thinking=False, allow_fallback=False,
-        )
-        abstract = self._remove_ai_meta_traces(abstract)
-        abstract = re.sub(r'(?im)^#+\s*abstract\s*', '', abstract).strip()
-        abstract = self.polish_academic_section(abstract, 'Abstract', abstract=True, mode=mode)
-        max_words = max(80, int(APP_CONFIG.get('manuscript_quality', {}).get('abstract_max_words', 200)))
-        return self._trim_at_sentence_boundary(abstract, max_words)
+        """Backward-compatible abstract-only facade over final front-matter generation."""
+        return self.generate_final_front_matter(
+            topic, keywords, manuscript, data_evidence=data_evidence, mode=mode
+        )['abstract']
 
     @staticmethod
     def _translation_language_rule(target_lang):
@@ -3199,7 +3307,7 @@ Output only the revised Discussion body, without the '# Discussion' heading."""
 
     @staticmethod
     def _translation_prompt(target_lang):
-        common = """Translate the supplied blocks from the locked English manuscript faithfully. Preserve every [[SP-Pxxxxxx]] paragraph marker and every [[SP-Txxxxxx]] protected token exactly once and in the same order. Protected tokens represent citations, statistics, identifiers, formulas, URLs/DOIs, hypotheses, abbreviations, or other immutable research objects and must never be translated or normalized. Preserve quotation meaning and conclusion direction. Do not add or remove claims. Use concise, accurate, rigorous academic language. Avoid metaphors, analogies, rhetorical questions, promotional language, formulaic transitions, and mechanical repetition. Output only the marked translations."""
+        common = """Translate the supplied blocks from the locked English manuscript faithfully. Preserve every [[SP-Pxxxxxx]] paragraph marker and every [[SP-Txxxxxx]] semantic anchor exactly once. Semantic anchors are typed immutable research objects. Keep each anchor attached to the same source sentence and semantic owner/claim; citation anchors must stay with the same claim. Anchor order may change inside the same sentence only when target-language grammar requires it. Never move an anchor into another sentence or claim. Do not translate, normalize, duplicate, or delete anchor placeholders. Preserve quotation meaning and conclusion direction. Do not add or remove claims. Use concise, accurate, rigorous academic language. Avoid metaphors, analogies, rhetorical questions, promotional language, formulaic transitions, and mechanical repetition. Output only the marked translations."""
         return common + ' ' + SSciPipelineAgent._translation_language_rule(target_lang)
 
     @staticmethod
@@ -3244,6 +3352,139 @@ Output only the revised Discussion body, without the '# Discussion' heading."""
             )
         )
 
+    @staticmethod
+    def _translation_date_regex():
+        months = (
+            r'January|February|March|April|May|June|July|August|September|October|November|December|'
+            r'Jan\.?|Feb\.?|Mar\.?|Apr\.?|Jun\.?|Jul\.?|Aug\.?|Sep\.?|Sept\.?|Oct\.?|Nov\.?|Dec\.?'
+        )
+        return (
+            rf'(?<![A-Za-z])(?:{months})\s+\d{{1,2}}(?:st|nd|rd|th)?(?:,)?\s+(?:19|20)\d{{2}}(?!\d)'
+            rf'|(?<![A-Za-z0-9])\d{{1,2}}(?:st|nd|rd|th)?\s+(?:{months})\s+(?:19|20)\d{{2}}(?!\d)'
+            r'|(?<!\d)(?:19|20)\d{2}-\d{1,2}-\d{1,2}(?!\d)'
+        )
+
+    @classmethod
+    def _canonicalize_translation_date(cls, value):
+        text = str(value or '').strip().replace(',', '')
+        iso = re.fullmatch(r'((?:19|20)\d{2})-(\d{1,2})-(\d{1,2})', text)
+        if iso:
+            year, month, day = map(int, iso.groups())
+            try:
+                return datetime(year, month, day).strftime('%Y-%m-%d')
+            except ValueError:
+                return ''
+        month_map = {
+            'jan':1,'january':1,'feb':2,'february':2,'mar':3,'march':3,'apr':4,'april':4,'may':5,
+            'jun':6,'june':6,'jul':7,'july':7,'aug':8,'august':8,'sep':9,'sept':9,'september':9,
+            'oct':10,'october':10,'nov':11,'november':11,'dec':12,'december':12,
+        }
+        m = re.fullmatch(r'([A-Za-z.]+)\s+(\d{1,2})(?:st|nd|rd|th)?\s+((?:19|20)\d{2})', text, flags=re.I)
+        if m:
+            month_name, day, year = m.groups()
+        else:
+            m = re.fullmatch(r'(\d{1,2})(?:st|nd|rd|th)?\s+([A-Za-z.]+)\s+((?:19|20)\d{2})', text, flags=re.I)
+            if not m:
+                return ''
+            day, month_name, year = m.groups()
+        month = month_map.get(month_name.rstrip('.').casefold())
+        if not month:
+            return ''
+        try:
+            return datetime(int(year), int(month), int(day)).strftime('%Y-%m-%d')
+        except ValueError:
+            return ''
+
+    @staticmethod
+    def _render_translation_date(canonical, target_lang):
+        try:
+            parsed = datetime.strptime(str(canonical), '%Y-%m-%d')
+        except Exception:
+            return str(canonical or '')
+        year, month, day = parsed.year, parsed.month, parsed.day
+        if 'Chinese' in str(target_lang):
+            return f'{year}年{month}月{day}日'
+        if 'Russian' in str(target_lang):
+            months = ['января','февраля','марта','апреля','мая','июня','июля','августа','сентября','октября','ноября','декабря']
+            return f'{day} {months[month-1]} {year} года'
+        if 'Kazakh' in str(target_lang):
+            months = ['қаңтар','ақпан','наурыз','сәуір','мамыр','маусым','шілде','тамыз','қыркүйек','қазан','қараша','желтоқсан']
+            return f'{year} жылғы {day} {months[month-1]}'
+        return parsed.strftime('%B %-d, %Y') if os.name != 'nt' else f'{parsed.strftime("%B")} {day}, {year}'
+
+    @classmethod
+    def _translation_date_canonicals(cls, value):
+        text = str(value or '')
+        found = []
+        for match in re.finditer(cls._translation_date_regex(), text, flags=re.I):
+            canonical = cls._canonicalize_translation_date(match.group(0))
+            if canonical:
+                found.append(canonical)
+        for year, month, day in re.findall(r'(?<!\d)((?:19|20)\d{2})年(\d{1,2})月(\d{1,2})日', text):
+            try:
+                found.append(datetime(int(year), int(month), int(day)).strftime('%Y-%m-%d'))
+            except ValueError:
+                pass
+        ru_months = {'января':1,'февраля':2,'марта':3,'апреля':4,'мая':5,'июня':6,'июля':7,'августа':8,'сентября':9,'октября':10,'ноября':11,'декабря':12}
+        for day, month_name, year in re.findall(r'(?<!\d)(\d{1,2})\s+(января|февраля|марта|апреля|мая|июня|июля|августа|сентября|октября|ноября|декабря)\s+((?:19|20)\d{2})(?:\s+года|\s+г\.)?', text, flags=re.I):
+            try:
+                found.append(datetime(int(year), ru_months[month_name.casefold()], int(day)).strftime('%Y-%m-%d'))
+            except ValueError:
+                pass
+        kz_months = {'қаңтар':1,'ақпан':2,'наурыз':3,'сәуір':4,'мамыр':5,'маусым':6,'шілде':7,'тамыз':8,'қыркүйек':9,'қазан':10,'қараша':11,'желтоқсан':12}
+        for year, day, month_name in re.findall(r'(?<!\d)((?:19|20)\d{2})\s+жылғы\s+(\d{1,2})\s+(қаңтар|ақпан|наурыз|сәуір|мамыр|маусым|шілде|тамыз|қыркүйек|қазан|қараша|желтоқсан)', text, flags=re.I):
+            try:
+                found.append(datetime(int(year), kz_months[month_name.casefold()], int(day)).strftime('%Y-%m-%d'))
+            except ValueError:
+                pass
+        return Counter(found)
+
+    @classmethod
+    def _numeric_tokens_without_dates(cls, value):
+        text = str(value or '')
+        text = re.sub(cls._translation_date_regex(), ' ', text, flags=re.I)
+        text = re.sub(r'(?<!\d)(?:19|20)\d{2}年\d{1,2}月\d{1,2}日', ' ', text)
+        text = re.sub(r'(?<!\d)\d{1,2}\s+(?:января|февраля|марта|апреля|мая|июня|июля|августа|сентября|октября|ноября|декабря)\s+(?:19|20)\d{2}(?:\s+года|\s+г\.)?', ' ', text, flags=re.I)
+        text = re.sub(r'(?<!\d)(?:19|20)\d{2}\s+жылғы\s+\d{1,2}\s+(?:қаңтар|ақпан|наурыз|сәуір|мамыр|маусым|шілде|тамыз|қыркүйек|қазан|қараша|желтоқсан)', ' ', text, flags=re.I)
+        return cls._numeric_tokens(text)
+
+    @classmethod
+    def _translation_anchor_type(cls, token):
+        value = str(token or '')
+        if re.fullmatch(cls._translation_date_regex(), value, flags=re.I): return 'DATE'
+        if re.fullmatch(r'\([^()\n]*?(?:19|20)\d{2}[a-z]?[^()\n]*?\)', value, flags=re.I): return 'CITATION'
+        if re.fullmatch(r'(?i:https?://[^\s)>]+|doi:\s*[^\s)>]+|10\.\d{4,9}/[-._;()/:A-Z0-9]+)', value): return 'DOI_URL'
+        if re.fullmatch(r'(?i:H\d+[A-Za-z]?)', value): return 'HYPOTHESIS'
+        if re.search(r'(?:p|t|f|z|r|β|χ²|R²|ΔR²)\s*(?:<=|>=|=|<|>|≤|≥)', value, flags=re.I): return 'STAT'
+        if re.fullmatch(r'(?:fsQCA|SmartPLS|Mplus|OpenAlex|DeepSeek|ChatGPT|RStudio|SPSS|AMOS|Stata)', value): return 'NAME'
+        if re.fullmatch(cls._translation_acronym_regex(), value): return 'ACRONYM'
+        if re.fullmatch(r'(?:QUOTE|CASE|RESP|P)-\d+', value, flags=re.I): return 'QUOTE_ID'
+        if re.fullmatch(cls._translation_numeric_regex(), value): return 'NUMBER'
+        if (value.startswith('`') and value.endswith('`')) or (value.startswith('$') and value.endswith('$')): return 'FORMULA'
+        return 'IMMUTABLE'
+
+    @staticmethod
+    def _translation_sentence_index(text, position):
+        prefix = str(text or '')[:max(0, int(position))]
+        # Chinese sentence punctuation does not require whitespace. For Latin/
+        # Cyrillic punctuation, count a boundary only before a plausible new
+        # sentence or end-of-prefix so abbreviations such as e.g. do not create
+        # false semantic-owner boundaries.
+        return len(re.findall(
+            r'[。！？]|[.!?](?=\s*(?:[A-ZА-ЯЁӘҒҚҢӨҰҮҺІ\["“]|$))', prefix
+        ))
+
+    @classmethod
+    def _translation_longform_acronym_pairs(cls, value):
+        pairs = []
+        text = str(value or '')
+        pattern = re.compile(r'(?<![A-Za-z])([A-Za-z][A-Za-z-]*(?:\s+[A-Za-z][A-Za-z-]*){1,5})\s*\(([^()\s]{2,20})\)')
+        for match in pattern.finditer(text):
+            long_form, acronym = match.group(1).strip(), match.group(2).strip()
+            if cls._translation_acronym_tokens(acronym) == Counter({acronym: 1}):
+                pairs.append((long_form, acronym))
+        return pairs
+
     @classmethod
     def _translation_protected_pattern(cls):
         # One-pass alternation prevents a placeholder created for a citation or
@@ -3251,7 +3492,10 @@ Output only the revised Discussion body, without the '# Discussion' heading."""
         # conservative: protect immutable research objects, not prose.
         acronym = cls._translation_acronym_regex()
         numeric = cls._translation_numeric_regex()
+        date_pattern = cls._translation_date_regex()
         return re.compile(
+            rf'(?:{date_pattern})'
+            r'|'
             r'(?i:https?://[^\s)>]+)'
             r'|(?i:\bdoi:\s*[^\s)>]+)'
             r'|(?i:\b10\.\d{4,9}/[-._;()/:A-Z0-9]+)'
@@ -3271,6 +3515,7 @@ Output only the revised Discussion body, without the '# Discussion' heading."""
 
     @classmethod
     def _protect_translation_tokens(cls, value):
+        source = str(value or '')
         mapping = {}
         counter = 0
         pattern = cls._translation_protected_pattern()
@@ -3279,13 +3524,25 @@ Output only the revised Discussion body, without the '# Discussion' heading."""
             nonlocal counter
             counter += 1
             placeholder = f'[[SP-T{counter:06d}]]'
-            mapping[placeholder] = match.group(0)
+            original = match.group(0)
+            anchor_type = cls._translation_anchor_type(original)
+            manifest = {'source': original, 'type': anchor_type}
+            if anchor_type == 'DATE':
+                manifest['canonical'] = cls._canonicalize_translation_date(original)
+            left = source[max(0, match.start() - 80):match.start()]
+            right = source[match.end():min(len(source), match.end() + 60)]
+            manifest['owner_hint'] = (left + '{ANCHOR}' + right).replace('\n', ' ')
+            mapping[placeholder] = manifest
             return placeholder
 
-        return pattern.sub(replace, str(value or '')), mapping
+        protected = pattern.sub(replace, source)
+        for placeholder, manifest in mapping.items():
+            position = protected.find(placeholder)
+            manifest['sentence_index'] = cls._translation_sentence_index(protected, position)
+        return protected, mapping
 
-    @staticmethod
-    def _restore_translation_tokens(value, mapping, block_id=''):
+    @classmethod
+    def _restore_translation_tokens(cls, value, mapping, block_id='', target_lang=''):
         text = str(value or '')
         found = Counter(re.findall(r'\[\[SP-T\d{6}\]\]', text))
         expected = Counter(mapping.keys())
@@ -3295,8 +3552,22 @@ Output only the revised Discussion body, without the '# Discussion' heading."""
             raise DeepSeekRequestError(
                 f'Translation protected placeholder mismatch in {block_id}: missing={missing}, added={added}.'
             )
-        for placeholder, original in mapping.items():
-            text = text.replace(placeholder, original)
+        for placeholder, raw_manifest in mapping.items():
+            manifest = raw_manifest if isinstance(raw_manifest, dict) else {'source': str(raw_manifest), 'type': 'IMMUTABLE'}
+            source_sentence = int(manifest.get('sentence_index') or 0)
+            target_sentence = cls._translation_sentence_index(text, text.find(placeholder))
+            if manifest.get('type') in {'DATE','CITATION','STAT','HYPOTHESIS','ACRONYM','NAME'} and target_sentence != source_sentence:
+                raise DeepSeekRequestError(
+                    f'Translation semantic anchor moved across sentence boundary in {block_id}: {placeholder}.'
+                )
+        for placeholder, raw_manifest in mapping.items():
+            manifest = raw_manifest if isinstance(raw_manifest, dict) else {'source': str(raw_manifest), 'type': 'IMMUTABLE'}
+            original = str(manifest.get('source') or '')
+            if target_lang and manifest.get('type') == 'DATE' and manifest.get('canonical'):
+                replacement = cls._render_translation_date(manifest.get('canonical'), target_lang)
+            else:
+                replacement = original
+            text = text.replace(placeholder, replacement)
         if re.search(r'\[\[SP-T\d{6}\]\]', text):
             raise DeepSeekRequestError(f'Translation left unresolved protected placeholders in {block_id}.')
         return text
@@ -3308,8 +3579,9 @@ Output only the revised Discussion body, without the '# Discussion' heading."""
         acronyms = sorted(self._translation_acronym_tokens(body))
         phrases = re.findall(r'\b(?:[A-Z][a-z]+(?:[- ][A-Z][a-z]+){1,3})\b', str(body or ''))
         recurring = [term for term, count in Counter(phrases).most_common() if count >= 2]
+        paired_long_forms = [long_form for long_form, _ in self._translation_longform_acronym_pairs(body)]
         term_limit = max(10, int(APP_CONFIG.get('translation_glossary_term_limit', 40)))
-        sources = list(dict.fromkeys(headings + recurring))[:term_limit]
+        sources = list(dict.fromkeys(headings + paired_long_forms + recurring))[:term_limit]
         missing = [term for term in sources if not str(mapping.get(term) or '').strip()]
         if missing:
             language_rule = self._translation_language_rule(target_lang)
@@ -3555,7 +3827,9 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
         return parsed
 
     def _validate_translation_block(self, source, translated, block_id, target_lang):
-        if self._numeric_tokens(source) != self._numeric_tokens(translated):
+        if self._translation_date_canonicals(source) != self._translation_date_canonicals(translated):
+            raise DeepSeekRequestError(f'Translation changed date content in {block_id}.')
+        if self._numeric_tokens_without_dates(source) != self._numeric_tokens_without_dates(translated):
             raise DeepSeekRequestError(f'Translation changed numerical content in {block_id}.')
         if self._translation_citation_tokens(source) != self._translation_citation_tokens(translated):
             raise DeepSeekRequestError(f'Translation changed citations in {block_id}.')
@@ -3570,6 +3844,11 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
                 f'Translation changed variable abbreviations in {block_id}: '
                 f'missing={missing}, added={added}.'
             )
+        for _long_form, acronym in self._translation_longform_acronym_pairs(source):
+            if not re.search(rf'[（(]\s*{re.escape(acronym)}\s*[）)]', str(translated or '')):
+                raise DeepSeekRequestError(
+                    f'Translation detached long-form/acronym pair in {block_id}: {acronym}.'
+                )
 
         source_compact = re.sub(r'\s+', '', str(source or ''))
         target_compact = re.sub(r'\s+', '', str(translated or ''))
@@ -3616,11 +3895,24 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
             f'[[SP-P{block_id}]]\n{protected_source}'
             for block_id, _, protected_source in protected_batch
         )
-        effective_prompt = system_prompt
+        semantic_manifest = {
+            block_id: [
+                {'id': placeholder, **manifest}
+                for placeholder, manifest in protected_maps.get(block_id, {}).items()
+            ]
+            for block_id, _source, _protected in protected_batch
+        }
+        effective_prompt = system_prompt + (
+            '\n<SEMANTIC_ANCHOR_MANIFEST>\n'
+            + json.dumps(semantic_manifest, ensure_ascii=False)
+            + '\n</SEMANTIC_ANCHOR_MANIFEST>\n'
+              'Use anchor type, canonical value, sentence_index, and owner_hint only to keep each placeholder attached to its original semantic owner. '
+              'Do not print the manifest. DATE anchors may change local word order inside their sentence; CITATION anchors must remain with their original claim.'
+        )
         if _strict:
             effective_prompt += (
-                '\nSTRICT RETRY: Copy every SP-P and SP-T marker byte-for-byte. Do not merge, drop, reorder, '
-                'translate, pluralize, or normalize any protected token.'
+                '\nSTRICT RETRY: Copy every SP-P and SP-T marker byte-for-byte. Do not merge, drop, translate, '
+                'pluralize, or normalize any protected token. Reposition an SP-T only inside the same sentence when target-language grammar requires it; never move it to another claim.'
             )
         result = self.call_deepseek(
             effective_prompt, marked_source,
@@ -3673,7 +3965,7 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
         for block_id, source in batch:
             try:
                 translated = self._restore_translation_tokens(
-                    parsed[block_id], protected_maps.get(block_id, {}), f'SP-P{block_id}'
+                    parsed[block_id], protected_maps.get(block_id, {}), f'SP-P{block_id}', target_lang
                 )
                 restored[block_id] = self._validate_translation_block_protected(
                     block_id, source, translated, target_lang

smartpaper_restore_bridge/__pycache__/desktop.ini

@@ -0,0 +1,2 @@
+[.ShellClassInfo]
+IconResource=C:\Program Files\Google\Drive File Stream\129.0.1.0\GoogleDriveFS.exe,27

utils/__pycache__/desktop.ini

@@ -0,0 +1,2 @@
+[.ShellClassInfo]
+IconResource=C:\Program Files\Google\Drive File Stream\129.0.1.0\GoogleDriveFS.exe,27