Step 4A-6-C-R3.2.8.5 Claim-Bound Translation Compiler + Refresh Diagnostics + 100ms Streaming + Four-Language Arabic Heading Numbering

__pycache__/desktop.ini

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

app.py

@@ -709,6 +709,14 @@ def _watch_task_status_live(task: dict) -> dict | None:
             key=f"sp_task_watch_{_safe_key(task_id)}",
         )
         boundary_task = watch_result.get("task") if isinstance(watch_result, dict) and watch_result.get("boundary") else None
+        if isinstance(watch_result, dict) and watch_result.get("boundary"):
+            navdiag = watch_result.get("ui_navdiag")
+            if isinstance(navdiag, dict):
+                try:
+                    safe_diag = json.dumps(navdiag, ensure_ascii=False, separators=(",", ":"))[:4000]
+                    logging.info("[SP_UI_NAVDIAG] task_id=%s snapshot=%s", task_id, safe_diag)
+                except Exception:
+                    logging.info("[SP_UI_NAVDIAG] task_id=%s snapshot_unserializable", task_id)
         if isinstance(boundary_task, dict) and str(boundary_task.get("task_id") or "") == task_id:
             st.session_state["sp_generation_task"] = dict(boundary_task)
             st.session_state["sp_last_ui_task_status"] = str(boundary_task.get("status") or "")

core/__pycache__/desktop.ini

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

core/__pycache__/pipeline_agent.cpython-313.pyc

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

core/generation_runner.py

@@ -33,7 +33,7 @@ ProgressCallback = Callable[..., None]
 MIN_FINAL_REFERENCES = 50
 LITERATURE_EVIDENCE_TARGET = 75
 CITATION_PLAN_TARGET = 70
-TRANSLATION_CONTRACT_VERSION = 'fact-ledger-v1'
+TRANSLATION_CONTRACT_VERSION = 'claim-bound-v1'
 
 
 def _clean_trailing_references(text, keywords=("reference", "references", "reference list", "参考文献")):

core/pipeline_agent.py

@@ -56,7 +56,7 @@ class CitationAuditError(DeepSeekRequestError):
 
 
 class SSciPipelineAgent:
-    TRANSLATION_CONTRACT_VERSION = 'fact-ledger-v1'
+    TRANSLATION_CONTRACT_VERSION = 'claim-bound-v1'
 
     def __init__(self, ds_key, s2_key=""):
         self.ds_key = str(ds_key or "").strip()
@@ -3310,7 +3310,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]] 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."""
+        common = """Translate the supplied blocks from the locked English manuscript faithfully. Preserve every [[SP-Pxxxxxx]] paragraph marker, [[SP-Cxxxxxx]] claim marker, and [[SP-Txxxxxx]] semantic anchor exactly once. Semantic anchors are typed immutable research objects. Keep each anchor attached to the same SP-C claim; citation anchors must stay with the same claim. Target-language sentence count and punctuation may differ naturally inside a claim. Never move an anchor into another 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
@@ -3583,8 +3583,73 @@ Output only the revised Discussion body, without the '# Discussion' heading."""
         )
 
     @classmethod
-    def _protect_translation_tokens(cls, value):
-        """Build a private fact ledger and replace model-inaccessible values."""
+    def _translation_claim_units(cls, value):
+        """Create stable source-side claim IDs without constraining target punctuation."""
+        text = str(value or '').strip()
+        if not text:
+            return []
+        abbreviations = ('e.g.', 'i.e.', 'et al.', 'fig.', 'dr.', 'mr.', 'ms.', 'prof.', 'vs.', 'no.', 'vol.')
+        boundaries = []
+        for match in re.finditer(r'[.!?](?=\s+(?:["“‘\[]?[A-Z0-9])|$)', text):
+            end = match.end()
+            prefix = text[:end].casefold()
+            is_abbrev = any(re.search(rf'(?:^|[^a-z]){re.escape(item)}$', prefix) for item in abbreviations)
+            if not is_abbrev:
+                boundaries.append(end)
+        claims = []
+        start = 0
+        for end in boundaries:
+            part = text[start:end].strip()
+            if part:
+                claims.append(part)
+            start = end
+        tail = text[start:].strip()
+        if tail:
+            claims.append(tail)
+        return [
+            {'claim_id': f'C{index:06d}', 'text': claim}
+            for index, claim in enumerate(claims or [text], start=1)
+        ]
+
+    @classmethod
+    def _translation_lexical_quantifier_candidates(cls, value):
+        """High-confidence source lexical quantities that may render as Arabic digits.
+
+        These candidates are private attribution evidence, not model-visible facts.
+        Rhetorical ordinals are intentionally excluded unless attached to a bounded
+        research/structural noun.
+        """
+        text = str(value or '')
+        cardinal = {
+            'zero':'0','one':'1','two':'2','three':'3','four':'4','five':'5','six':'6',
+            'seven':'7','eight':'8','nine':'9','ten':'10','eleven':'11','twelve':'12',
+        }
+        ordinal = {
+            'first':'1','second':'2','third':'3','fourth':'4','fifth':'5','sixth':'6',
+            'seventh':'7','eighth':'8','ninth':'9','tenth':'10','eleventh':'11','twelfth':'12',
+        }
+        measurable_nouns = (
+            r'mechanisms?|groups?|stages?|steps?|waves?|models?|hypotheses?|dimensions?|factors?|items?|'
+            r'rounds?|phases?|samples?|studies?|analyses?|conditions?|paths?|constructs?|measures?|components?|'
+            r'categories?|levels?|questions?|options?|variables?|sections?|claims?|explanations?|participants?|teams?'
+        )
+        found = []
+        cardinal_words = '|'.join(cardinal)
+        for match in re.finditer(rf'(?i)\b({cardinal_words})\s+({measurable_nouns})\b', text):
+            found.append(cardinal[match.group(1).casefold()])
+        ordinal_words = '|'.join(ordinal)
+        for match in re.finditer(rf'(?i)\b({ordinal_words})\s+({measurable_nouns})\b', text):
+            found.append(ordinal[match.group(1).casefold()])
+        for match in re.finditer(r'(?i)\b(twice|twofold|threefold|fourfold)\b', text):
+            found.append({'twice':'2','twofold':'2','threefold':'3','fourfold':'4'}[match.group(1).casefold()])
+        # one-to-one is a relational form with two explicit quantitative roles.
+        if re.search(r'(?i)\bone[- ]to[- ]one\b', text):
+            found.extend(['1', '1'])
+        return Counter(found)
+
+    @classmethod
+    def _protect_translation_tokens(cls, value, claim_id='C000001'):
+        """Protect one claim while keeping factual values in a private server ledger."""
         source = str(value or '')
         mapping = {}
         counter = 0
@@ -3598,32 +3663,65 @@ Output only the revised Discussion body, without the '# Discussion' heading."""
             anchor_type = cls._translation_anchor_type(original)
             mapping[placeholder] = {
                 'fact_id': f'F{counter:06d}',
-                'source': original,                    # private server ledger only
+                'source': original,
                 'type': anchor_type,
                 'canonical': cls._translation_fact_canonical(original, anchor_type),
                 'render_policy': cls._translation_fact_render_policy(anchor_type),
+                'claim_id': str(claim_id or 'C000001'),
+                # Kept only as diagnostic compatibility; never authoritative.
+                'sentence_index': 0,
             }
             return placeholder
 
-        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
+        return pattern.sub(replace, source), mapping
+
+    @classmethod
+    def _protect_translation_claims(cls, value):
+        """Compile a paragraph into claim markers plus a private fact ledger."""
+        claims = cls._translation_claim_units(value)
+        pattern = cls._translation_protected_pattern()
+        mapping = {}
+        claim_sources = {}
+        protected_parts = []
+        fact_counter = 0
+        for claim in claims:
+            claim_id = claim['claim_id']
+            claim_source = claim['text']
+            claim_sources[claim_id] = claim_source
+
+            def replace(match, _claim_id=claim_id):
+                nonlocal fact_counter
+                fact_counter += 1
+                placeholder = f'[[SP-T{fact_counter:06d}]]'
+                original = match.group(0)
+                anchor_type = cls._translation_anchor_type(original)
+                mapping[placeholder] = {
+                    'fact_id': f'F{fact_counter:06d}',
+                    'source': original,
+                    'type': anchor_type,
+                    'canonical': cls._translation_fact_canonical(original, anchor_type),
+                    'render_policy': cls._translation_fact_render_policy(anchor_type),
+                    'claim_id': _claim_id,
+                    'sentence_index': 0,
+                }
+                return placeholder
+
+            protected_claim = pattern.sub(replace, claim_source)
+            protected_parts.append(f'[[SP-{claim_id}]]\n{protected_claim}')
+        return '\n'.join(protected_parts), mapping, claim_sources
 
     @classmethod
     def _model_safe_translation_manifest(cls, mapping):
-        """Expose only placement metadata; factual values remain server-private."""
+        """Expose claim/type metadata only; factual values remain server-private."""
         safe = []
         for placeholder, raw in (mapping or {}).items():
             item = raw if isinstance(raw, dict) else {'type':'IMMUTABLE'}
-            anchor_type = str(item.get('type') or 'IMMUTABLE')
             safe.append({
                 'id': placeholder,
                 'fact_id': str(item.get('fact_id') or placeholder),
-                'type': anchor_type,
-                'sentence_index': int(item.get('sentence_index') or 0),
-                'mobility': 'same_sentence' if anchor_type in {'DATE','CITATION'} else 'same_owner',
+                'type': str(item.get('type') or 'IMMUTABLE'),
+                'claim_id': str(item.get('claim_id') or 'C000001'),
+                'mobility': 'same_claim',
             })
         return safe
 
@@ -3635,10 +3733,10 @@ Output only the revised Discussion body, without the '# Discussion' heading."""
                 item = raw if isinstance(raw, dict) else {'source':str(raw),'type':'IMMUTABLE'}
                 records.append({
                     'block_id': str(block_id),
+                    'claim_id': str(item.get('claim_id') or 'C000001'),
                     'fact_id': str(item.get('fact_id') or placeholder),
                     'type': str(item.get('type') or 'IMMUTABLE'),
                     'canonical': str(item.get('canonical') or item.get('source') or ''),
-                    'sentence_index': int(item.get('sentence_index') or 0),
                     'render_policy': str(item.get('render_policy') or 'exact'),
                 })
         payload = json.dumps(records, ensure_ascii=False, sort_keys=True, separators=(',', ':')).encode('utf-8')
@@ -3646,7 +3744,7 @@ Output only the revised Discussion body, without the '# Discussion' heading."""
 
     @classmethod
     def translation_fact_ledger_hash(cls, section_text):
-        """Deterministic source ledger hash used by translation checkpoint reuse."""
+        """Deterministic claim-bound ledger hash used by translation checkpoint reuse."""
         units = cls._translation_body_units(section_text)
         ledger = {}
         body_index = 0
@@ -3654,7 +3752,7 @@ Output only the revised Discussion body, without the '# Discussion' heading."""
             if unit.get('kind') != 'body':
                 continue
             body_index += 1
-            _protected, mapping = cls._protect_translation_tokens(unit.get('text') or '')
+            _protected, mapping, _claims = cls._protect_translation_claims(unit.get('text') or '')
             ledger[f'{body_index:06d}'] = mapping
         return cls._fact_ledger_hash(ledger)
 
@@ -3668,11 +3766,62 @@ Output only the revised Discussion body, without the '# Discussion' heading."""
             return str(item.get('canonical'))
         return str(item.get('source') or '')
 
+    @staticmethod
+    def _translation_claim_marker(claim_id):
+        return f'[[SP-{claim_id}]]'
+
+    @classmethod
+    def _parse_translation_claim_segments(cls, value, expected_claim_ids=None):
+        text = str(value or '')
+        pattern = re.compile(r'(?m)^\[\[SP-(C\d{6})\]\]\s*$')
+        matches = list(pattern.finditer(text))
+        expected = list(expected_claim_ids or [])
+        if not matches:
+            if len(expected) <= 1:
+                claim_id = expected[0] if expected else 'C000001'
+                return [claim_id], {claim_id: text.strip()}
+            raise DeepSeekRequestError(f'Translation claim marker mismatch: expected={expected}, got=[].')
+        found = [match.group(1) for match in matches]
+        if expected and found != expected:
+            raise DeepSeekRequestError(f'Translation claim marker mismatch: expected={expected}, got={found}.')
+        if text[:matches[0].start()].strip():
+            raise DeepSeekRequestError('Translation output contained unexpected text before the first SP-C marker.')
+        segments = {}
+        for index, match in enumerate(matches):
+            end = matches[index + 1].start() if index + 1 < len(matches) else len(text)
+            segment = text[match.end():end].strip()
+            if not segment:
+                raise DeepSeekRequestError(f'Translation claim {match.group(1)} is empty.')
+            segments[match.group(1)] = segment
+        return found, segments
+
+    @classmethod
+    def _compose_translation_claim_segments(cls, claim_order, segments):
+        return '\n'.join(
+            f'{cls._translation_claim_marker(claim_id)}\n{str(segments.get(claim_id) or "").strip()}'
+            for claim_id in claim_order
+        ).strip()
+
+    @classmethod
+    def _strip_translation_claim_markers(cls, value):
+        text = str(value or '')
+        matches = list(re.finditer(r'(?m)^\[\[SP-(C\d{6})\]\]\s*$', text))
+        if not matches:
+            return text.strip()
+        parts = []
+        for index, match in enumerate(matches):
+            end = matches[index + 1].start() if index + 1 < len(matches) else len(text)
+            part = text[match.end():end].strip()
+            if part:
+                parts.append(part)
+        return ' '.join(parts).strip()
+
     @classmethod
     def _translation_unowned_objects(cls, protected_target):
-        """Find factual objects invented by the model outside SP-T anchors."""
+        """Find non-anchor factual surfaces; numeric candidates are adjudicated per claim."""
         text = re.sub(r'\[\[SP-T\d{6}\]\]', ' ', str(protected_target or ''))
         text = re.sub(r'\[\[SP-P\d{6}\]\]', ' ', text)
+        text = re.sub(r'\[\[SP-C\d{6}\]\]', ' ', text)
         unowned = {
             'numeric': list(cls._numeric_tokens(text).elements()),
             'citation': list(cls._translation_citation_tokens(text).elements()),
@@ -3688,8 +3837,9 @@ Output only the revised Discussion body, without the '# Discussion' heading."""
         return {key: values for key, values in unowned.items() if values}
 
     @classmethod
-    def _validate_translation_skeleton(cls, value, mapping, block_id=''):
-        found = Counter(re.findall(r'\[\[SP-T\d{6}\]\]', str(value or '')))
+    def _validate_translation_skeleton(cls, value, mapping, block_id='', claim_sources=None):
+        text = str(value or '')
+        found = Counter(re.findall(r'\[\[SP-T\d{6}\]\]', text))
         expected = Counter((mapping or {}).keys())
         if found != expected:
             missing = list((expected - found).elements())[:8]
@@ -3697,47 +3847,78 @@ Output only the revised Discussion body, without the '# Discussion' heading."""
             raise DeepSeekRequestError(
                 f'Translation protected placeholder mismatch in {block_id}: missing={missing}, added={added}.'
             )
-        unowned = cls._translation_unowned_objects(value)
-        if unowned:
-            safe_summary = {key: len(values) for key, values in unowned.items()}
-            logging.warning('Translation fact integrity failed: block=%s unowned=%s', block_id, safe_summary)
-            raise DeepSeekRequestError(f'Translation introduced unowned factual content in {block_id}: {safe_summary}.')
-        target_text = str(value or '')
+
+        private_claims = dict(claim_sources or {})
+        expected_claim_ids = list(private_claims)
+        if not expected_claim_ids:
+            expected_claim_ids = list(dict.fromkeys(
+                str((raw if isinstance(raw, dict) else {}).get('claim_id') or 'C000001')
+                for raw in (mapping or {}).values()
+            )) or ['C000001']
+        claim_order, target_claims = cls._parse_translation_claim_segments(text, expected_claim_ids)
+
+        # Every protected fact must remain inside its source claim; target
+        # sentence count/punctuation is deliberately non-authoritative.
         for placeholder, raw_manifest in (mapping or {}).items():
             manifest = raw_manifest if isinstance(raw_manifest, dict) else {'type':'IMMUTABLE'}
-            source_sentence = int(manifest.get('sentence_index') or 0)
-            target_sentence = cls._translation_sentence_index(target_text, target_text.find(placeholder))
-            if target_sentence != source_sentence:
+            claim_id = str(manifest.get('claim_id') or 'C000001')
+            if placeholder not in str(target_claims.get(claim_id) or ''):
                 raise DeepSeekRequestError(
-                    f'Translation fact moved across sentence boundary in {block_id}: {manifest.get("fact_id") or placeholder}.'
+                    f'Translation fact moved across claim boundary in {block_id}: {manifest.get("fact_id") or placeholder}.'
                 )
-        # Preserve the relative order of hard quantitative/identifier facts
-        # inside each claim. DATE/CITATION/NAME may legitimately move for target
-        # grammar, but two sample/statistical values must never trade owners.
+
         ordered_types = {'NUMBER','QUANTITY','STAT','HYPOTHESIS','DOI_URL','FORMULA','QUOTE_ID'}
-        for sentence_index in sorted({int((m if isinstance(m, dict) else {}).get('sentence_index') or 0) for m in (mapping or {}).values()}):
+        for claim_id in claim_order:
+            target_claim = str(target_claims.get(claim_id) or '')
             expected_order = [
-                ph for ph, raw in (mapping or {}).items()
-                if int((raw if isinstance(raw, dict) else {}).get('sentence_index') or 0) == sentence_index
+                placeholder for placeholder, raw in (mapping or {}).items()
+                if str((raw if isinstance(raw, dict) else {}).get('claim_id') or 'C000001') == claim_id
                 and str((raw if isinstance(raw, dict) else {}).get('type') or '') in ordered_types
             ]
             if len(expected_order) > 1:
-                actual_order = sorted(expected_order, key=lambda ph: target_text.find(ph))
+                actual_order = sorted(expected_order, key=lambda placeholder: target_claim.find(placeholder))
                 if actual_order != expected_order:
                     raise DeepSeekRequestError(
-                        f'Translation fact order changed within owner sentence in {block_id}: sentence={sentence_index}.'
+                        f'Translation fact order changed within owner claim in {block_id}: claim={claim_id}.'
+                    )
+
+            unowned = cls._translation_unowned_objects(target_claim)
+            numeric = list(unowned.pop('numeric', []))
+            if unowned:
+                safe_summary = {key: len(values) for key, values in unowned.items()}
+                logging.warning('Translation fact integrity failed: block=%s claim=%s unowned=%s', block_id, claim_id, safe_summary)
+                raise DeepSeekRequestError(
+                    f'Translation introduced unowned factual content in {block_id} claim={claim_id}: {safe_summary}.'
+                )
+            if numeric:
+                allowed = cls._translation_lexical_quantifier_candidates(private_claims.get(claim_id, ''))
+                unresolved = []
+                for token in numeric:
+                    canonical = cls._canonicalize_numeric_fact(token)
+                    if allowed.get(canonical, 0) > 0:
+                        allowed[canonical] -= 1
+                    else:
+                        unresolved.append(token)
+                if unresolved:
+                    safe_summary = {'numeric': len(unresolved)}
+                    logging.warning(
+                        'Translation fact integrity failed: block=%s claim=%s unowned=%s suspect_tokens=%s',
+                        block_id, claim_id, safe_summary, unresolved[:4],
+                    )
+                    raise DeepSeekRequestError(
+                        f'Translation introduced unowned factual content in {block_id} claim={claim_id}: {safe_summary}.'
                     )
         return True
 
     @classmethod
-    def _restore_translation_tokens(cls, value, mapping, block_id='', target_lang=''):
+    def _restore_translation_tokens(cls, value, mapping, block_id='', target_lang='', claim_sources=None, keep_claim_markers=False):
         text = str(value or '')
-        cls._validate_translation_skeleton(text, mapping, block_id)
+        cls._validate_translation_skeleton(text, mapping, block_id, claim_sources=claim_sources)
         for placeholder, manifest in (mapping or {}).items():
             text = text.replace(placeholder, cls._render_translation_fact(manifest, target_lang))
         if re.search(r'\[\[SP-T\d{6}\]\]', text):
             raise DeepSeekRequestError(f'Translation left unresolved protected placeholders in {block_id}.')
-        return text
+        return text.strip() if keep_claim_markers else cls._strip_translation_claim_markers(text)
 
     def extend_translation_glossary(self, body, target_lang, existing=None):
         """Extend a task-level glossary without remapping an existing term."""
@@ -3826,12 +4007,7 @@ SECTION: {section_name}
         return True
 
     def audit_translation_blocks(self, sources, translations, target_lang, glossary=None, section_name=''):
-        """Return block-localized translation QA issues without rewriting good blocks.
-
-        This combines semantic-equivalence and target-language quality review so
-        a failed paragraph can be regenerated independently rather than forcing
-        a whole-section translation retry.
-        """
+        """Return claim-local bounded QA issue codes without rewriting text."""
         source_map = {str(key): str(value or '').strip() for key, value in dict(sources or {}).items()}
         target_map = {str(key): str(value or '').strip() for key, value in dict(translations or {}).items()}
         expected_ids = [key for key in source_map if key in target_map]
@@ -3840,59 +4016,72 @@ SECTION: {section_name}
         if not expected_ids:
             return {}
 
+        allowed_codes = {
+            'OMITTED_CLAIM','ADDED_CLAIM','NEGATION_DRIFT','CAUSALITY_STRENGTH_DRIFT',
+            'UNCERTAINTY_DRIFT','TERMINOLOGY','GRAMMAR','LANGUAGE_CONTAMINATION',
+            'CITATION_ATTACHMENT','ACRONYM_ATTACHMENT','SEMANTIC_DRIFT',
+        }
+        claim_rows = []
         glossary_value = dict(glossary or {})
-        batch_size = 6
+        for block_id in expected_ids:
+            source_claims = self._translation_claim_units(source_map[block_id])
+            claim_order = [item['claim_id'] for item in source_claims]
+            _order, target_claims = self._parse_translation_claim_segments(target_map[block_id], claim_order)
+            for item in source_claims:
+                claim_id = item['claim_id']
+                claim_rows.append({
+                    'id': f'SP-P{block_id}-{claim_id}',
+                    'block_id': block_id,
+                    'claim_id': claim_id,
+                    'english': item['text'],
+                    'target': target_claims[claim_id],
+                })
+
         issues = {}
-        for offset in range(0, len(expected_ids), batch_size):
-            batch_ids = expected_ids[offset:offset + batch_size]
-            relevant_glossary = {}
-            joined_source = '\n'.join(source_map[block_id] for block_id in batch_ids)
-            for source_term, target_term in glossary_value.items():
-                if source_term and str(source_term) in joined_source:
-                    relevant_glossary[str(source_term)] = str(target_term)
+        batch_size = 8
+        for offset in range(0, len(claim_rows), batch_size):
+            rows = claim_rows[offset:offset + batch_size]
+            joined_source = '\n'.join(row['english'] for row in rows)
+            relevant_glossary = {
+                str(source_term): str(target_term)
+                for source_term, target_term in glossary_value.items()
+                if source_term and str(source_term) in joined_source
+            }
             payload = {
                 'section': str(section_name or 'section'),
                 'target_language': target_lang,
                 'glossary': relevant_glossary,
-                'items': [
-                    {
-                        'id': f'SP-P{block_id}',
-                        'english': source_map[block_id],
-                        'target': target_map[block_id],
-                    }
-                    for block_id in batch_ids
-                ],
+                'allowed_issue_codes': sorted(allowed_codes),
+                'items': [{'id': row['id'], 'english': row['english'], 'target': row['target']} for row in rows],
             }
-            system_prompt = f"""You are a bilingual academic translation QA reviewer for {target_lang}.
-Review EACH supplied block independently. Do not rewrite. Check: (1) no substantive claim is omitted or added; (2) negation, direction, uncertainty, association-versus-causation strength, hypothesis/result status, limitations, and quotation meaning are preserved; (3) the target is natural, grammatically correct academic {target_lang}, not language-contaminated; (4) frozen glossary terms are used consistently, allowing only grammatical inflection where the target language requires it.
-For Russian, reject noticeable Kazakh-language contamination. For Kazakh, reject Russian wording/syntax masquerading as Kazakh and require natural Kazakh morphology. For Simplified Chinese, require natural academic Chinese while preserving protected research objects.
-Return valid JSON only: {{"items":[{{"id":"SP-P000001","ok":true,"issues":[]}}]}}. Return every supplied id exactly once."""
+            system_prompt = f"""You are a bilingual academic translation QA classifier for {target_lang}.
+Review EACH claim independently. Do not rewrite and do not provide free-form explanations. Check semantic equivalence and language quality: omissions/additions, negation, uncertainty, association-versus-causation strength, terminology, grammar, language contamination, citation attachment, and acronym attachment.
+Return valid JSON only in this exact form: {{"items":[{{"id":"SP-P000001-C000001","ok":true,"codes":[]}}]}}.
+If ok=false, codes MUST contain only values from allowed_issue_codes. Never return numbered prose, examples, quotes, or corrective wording. Return every supplied id exactly once."""
             response = self.call_deepseek(
-                system_prompt,
-                json.dumps(payload, ensure_ascii=False),
-                max_tokens=max(1200, min(3600, 700 + 420 * len(batch_ids))),
+                system_prompt, json.dumps(payload, ensure_ascii=False),
+                max_tokens=max(1200, min(3600, 650 + 260 * len(rows))),
                 temp=0.0, model_role='reasoning', thinking=False, allow_fallback=False,
             )
             parsed = self._extract_json_from_text(response)
-            rows = parsed.get('items', []) if isinstance(parsed, dict) else []
-            by_id = {}
-            for row in rows:
-                if not isinstance(row, dict):
-                    continue
-                raw_id = str(row.get('id') or '').strip()
-                match = re.fullmatch(r'SP-P(\d{6})', raw_id)
-                if match and match.group(1) in batch_ids and match.group(1) not in by_id:
-                    by_id[match.group(1)] = row
-            if set(by_id) != set(batch_ids):
+            returned = parsed.get('items', []) if isinstance(parsed, dict) else []
+            by_id = {str(row.get('id') or ''): row for row in returned if isinstance(row, dict)}
+            expected_row_ids = [row['id'] for row in rows]
+            if set(by_id) != set(expected_row_ids):
                 raise DeepSeekRequestError(
-                    f'Translation block QA id mismatch: expected={batch_ids}, got={sorted(by_id)}.'
+                    f'Translation claim QA id mismatch: expected={expected_row_ids}, got={sorted(by_id)}.'
                 )
-            for block_id in batch_ids:
-                row = by_id[block_id]
-                if row.get('ok') is True:
+            row_lookup = {row['id']: row for row in rows}
+            for row_id in expected_row_ids:
+                returned_row = by_id[row_id]
+                if returned_row.get('ok') is True:
                     continue
-                detail = [str(item).strip() for item in (row.get('issues') or []) if str(item).strip()]
-                issues[block_id] = detail[:5] or ['translation quality was not confirmed']
+                raw_codes = [str(code or '').strip().upper() for code in (returned_row.get('codes') or [])]
+                codes = [code for code in raw_codes if code in allowed_codes]
+                if not codes:
+                    codes = ['SEMANTIC_DRIFT']
+                meta = row_lookup[row_id]
+                issues.setdefault(meta['block_id'], {})[meta['claim_id']] = list(dict.fromkeys(codes))[:5]
         return issues
 
     @staticmethod
@@ -4032,20 +4221,16 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
         return translated
 
     def _translate_marked_batch_with_recovery(self, batch, system_prompt, target_lang, _strict=False):
-        """Translate one marked batch with protected tokens and bounded recovery.
-
-        Multi-block marker/protected-token failures are binary-split first.  A
-        single block may accept a marker-free response only when it is the sole
-        source, after which every protected object and existing integrity gate
-        must still pass.
-        """
+        """Translate SP-P blocks through claim-bound, value-blind protected skeletons."""
         expected_ids = [block_id for block_id, _ in batch]
         protected_batch = []
         protected_maps = {}
+        claim_sources_by_block = {}
         for block_id, source in batch:
-            protected_source, token_map = self._protect_translation_tokens(source)
+            protected_source, token_map, claim_sources = self._protect_translation_claims(source)
             protected_batch.append((block_id, source, protected_source))
             protected_maps[block_id] = token_map
+            claim_sources_by_block[block_id] = claim_sources
         marked_source = '\n\n'.join(
             f'[[SP-P{block_id}]]\n{protected_source}'
             for block_id, _, protected_source in protected_batch
@@ -4058,23 +4243,20 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
             '\n<SEMANTIC_ANCHOR_MANIFEST>\n'
             + json.dumps(semantic_manifest, ensure_ascii=False)
             + '\n</SEMANTIC_ANCHOR_MANIFEST>\n'
-              'This manifest intentionally contains no factual values. Use only fact type and sentence ownership to place each placeholder. '
-              'Never infer, spell out, calculate, or recreate a hidden number, date, citation, acronym, name, formula, or identifier. '
-              'Do not print the manifest. DATE and CITATION anchors may move only within their original sentence when grammar requires it.'
+              'This manifest intentionally contains no factual values. Preserve every SP-P, SP-C, and SP-T marker exactly. '
+              'Each SP-C marker identifies one source claim. A target claim may contain one or more grammatical sentences, but every protected fact must remain inside its original SP-C claim. '
+              'Never infer, spell out, calculate, or recreate a hidden number, date, citation, acronym, name, formula, or identifier. Do not print the manifest.'
         )
         if _strict:
             effective_prompt += (
-                '\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.'
+                '\nSTRICT RETRY: Copy every SP-P, SP-C, and SP-T marker byte-for-byte. Do not merge, drop, translate, '
+                'pluralize, or normalize any protected token. Do not move any SP-T outside its SP-C claim.'
             )
         result = self.call_deepseek(
             effective_prompt, marked_source,
             max_tokens=max(1800, min(9000, self._count_tokens(marked_source) * 2 + 1200)),
             temp=0.0, model_role='translation', thinking=False, allow_fallback=False,
         )
-        # Translation is non-destructive: never run generic manuscript cleanup
-        # on target-language text. Marker/placeholder parsing rejects malformed
-        # output instead of deleting potentially legitimate manuscript lines.
         try:
             parsed = self._parse_marked_translation(result, expected_ids)
         except DeepSeekRequestError as error:
@@ -4117,19 +4299,18 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
         failed = {}
         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}', target_lang
-                )
-                restored[block_id] = self._validate_translation_block_protected(
-                    block_id, source, translated, target_lang
+                translated_with_claims = self._restore_translation_tokens(
+                    parsed[block_id], protected_maps.get(block_id, {}), f'SP-P{block_id}', target_lang,
+                    claim_sources=claim_sources_by_block.get(block_id, {}), keep_claim_markers=True,
                 )
+                clean_translation = self._strip_translation_claim_markers(translated_with_claims)
+                self._validate_translation_block_protected(block_id, source, clean_translation, target_lang)
+                restored[block_id] = translated_with_claims
             except DeepSeekRequestError as error:
                 failed[block_id] = error
 
         if failed:
             if _strict:
-                # A strict isolated retry already used the protected gateway.
-                # Failing again is fail-closed; never fall back to raw source.
                 first_id = next(iter(failed))
                 raise failed[first_id]
             source_by_id = {block_id: source for block_id, source in batch}
@@ -4144,6 +4325,36 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
                 restored[block_id] = recovered[block_id]
         return restored
 
+    def _translate_single_claim_with_recovery(self, block_id, claim_id, source_claim, system_prompt, target_lang, issue_codes):
+        """Regenerate one failed claim using bounded QA codes only."""
+        protected_claim, mapping = self._protect_translation_tokens(source_claim, claim_id=claim_id)
+        marked_source = f'[[SP-P{block_id}]]\n[[SP-{claim_id}]]\n{protected_claim}'
+        safe_manifest = self._model_safe_translation_manifest(mapping)
+        codes = [str(code or '').strip().upper() for code in (issue_codes or []) if str(code or '').strip()]
+        effective_prompt = system_prompt + (
+            '\nCLAIM QUALITY RETRY. Repair only this one claim. The only permitted repair signals are the following bounded issue codes: '
+            + json.dumps(codes[:5], ensure_ascii=False)
+            + '. Do not infer any examples or numbered instructions from those codes. Preserve every SP-P, SP-C, and SP-T marker byte-for-byte. '
+              'Do not add claims or factual content. Return only the marked translated claim.'
+            + '\n<SEMANTIC_ANCHOR_MANIFEST>\n'
+            + json.dumps({block_id: safe_manifest}, ensure_ascii=False)
+            + '\n</SEMANTIC_ANCHOR_MANIFEST>'
+        )
+        result = self.call_deepseek(
+            effective_prompt, marked_source,
+            max_tokens=max(1200, min(2600, self._count_tokens(marked_source) * 2 + 900)),
+            temp=0.0, model_role='translation', thinking=False, allow_fallback=False,
+        )
+        parsed = self._parse_marked_translation(result, [block_id])
+        restored = self._restore_translation_tokens(
+            parsed[block_id], mapping, f'SP-P{block_id}', target_lang,
+            claim_sources={claim_id: source_claim}, keep_claim_markers=True,
+        )
+        clean = self._strip_translation_claim_markers(restored)
+        self._validate_translation_block_protected(block_id, source_claim, clean, target_lang)
+        _order, segments = self._parse_translation_claim_segments(restored, [claim_id])
+        return segments[claim_id]
+
     def _audit_translation_blocks_with_retry(
         self, sources, translations, target_lang, glossary=None, section_name='', max_attempts=2
     ):
@@ -4214,35 +4425,45 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
                 local_round = 0
                 while quality_issues and local_round < 2:
                     local_round += 1
-                    failed_ids = sorted(quality_issues)
+                    failed_pairs = [
+                        (block_id, claim_id, codes)
+                        for block_id, claim_map in sorted(quality_issues.items())
+                        for claim_id, codes in sorted((claim_map or {}).items())
+                    ]
                     logging.warning(
-                        'Translation block-local QA recovery: section=%s round=%s failed=%s',
-                        section_name or 'section', local_round, failed_ids,
+                        'Translation claim-local QA recovery: section=%s round=%s failed=%s',
+                        section_name or 'section', local_round,
+                        [f'SP-P{block_id}-{claim_id}' for block_id, claim_id, _codes in failed_pairs],
                     )
-                    for block_id in failed_ids:
-                        details = '; '.join(quality_issues.get(block_id) or [])[:700]
-                        quality_prompt = (
-                            system_prompt
-                            + '\nQUALITY RETRY FOR ONE BLOCK: Correct only the translation-quality issue(s) listed below. '
-                              'Preserve every protected placeholder and SP-P marker exactly. Do not add claims.\n'
-                            + details
-                        )
-                        retry = self._translate_marked_batch_with_recovery(
-                            [(block_id, source_blocks[block_id])], quality_prompt, target_lang, _strict=True
+                    touched_blocks = set()
+                    for block_id, claim_id, codes in failed_pairs:
+                        source_claims = {
+                            item['claim_id']: item['text'] for item in self._translation_claim_units(source_blocks[block_id])
+                        }
+                        if claim_id not in source_claims:
+                            raise DeepSeekRequestError(
+                                f'Translation claim-local QA source mismatch: SP-P{block_id}-{claim_id}.'
+                            )
+                        claim_order = list(source_claims)
+                        _order, segments = self._parse_translation_claim_segments(translations[block_id], claim_order)
+                        segments[claim_id] = self._translate_single_claim_with_recovery(
+                            block_id, claim_id, source_claims[claim_id], system_prompt, target_lang, codes
                         )
-                        translations[block_id] = retry[block_id]
+                        translations[block_id] = self._compose_translation_claim_segments(claim_order, segments)
+                        touched_blocks.add(block_id)
                     quality_issues = self._audit_translation_blocks_with_retry(
-                        {block_id: source_blocks[block_id] for block_id in failed_ids},
-                        {block_id: translations[block_id] for block_id in failed_ids},
+                        {block_id: source_blocks[block_id] for block_id in sorted(touched_blocks)},
+                        {block_id: translations[block_id] for block_id in sorted(touched_blocks)},
                         target_lang, frozen_glossary, section_name=section_name or 'frozen section', max_attempts=2,
                     )
                 if quality_issues:
                     detail = '; '.join(
-                        f'SP-P{block_id}: {"; ".join(messages)}'
-                        for block_id, messages in sorted(quality_issues.items())
+                        f'SP-P{block_id}-{claim_id}: {",".join(codes)}'
+                        for block_id, claim_map in sorted(quality_issues.items())
+                        for claim_id, codes in sorted((claim_map or {}).items())
                     )
                     raise DeepSeekRequestError(
-                        f'Translation block-local QA failed for {section_name or "section"}: {detail[:1000]}'
+                        f'Translation claim-local QA failed for {section_name or "section"}: {detail[:1000]}'
                     )
 
                 # Rebuild after any localized repairs, then apply deterministic
@@ -4257,7 +4478,7 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
                         output_units.append('#' * int(unit['level']) + ' ' + translated_heading)
                     else:
                         body_index += 1
-                        output_units.append(translations[f'{body_index:06d}'])
+                        output_units.append(self._strip_translation_claim_markers(translations[f'{body_index:06d}']))
                 output = '\n\n'.join(output_units).strip()
                 self.validate_translation_alignment(value, output)
                 self._validate_translation_language_quality(output, target_lang)
@@ -4275,7 +4496,7 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
                 last_error = error
                 message = str(error)
                 if (
-                    message.startswith('Translation block-local QA failed')
+                    message.startswith('Translation claim-local QA failed')
                     or message.startswith('Translation alignment')
                     or message.startswith('Translation changed ')
                     or message.startswith('Translation protected ')
@@ -4342,7 +4563,7 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
                 output_units.append('#' * int(unit['level']) + ' ' + translated_heading)
             else:
                 body_index += 1
-                output_units.append(translations[f'{body_index:06d}'])
+                output_units.append(self._strip_translation_claim_markers(translations[f'{body_index:06d}']))
 
         output = '\n\n'.join(output_units).strip()
         if references:

smartpaper_restore_bridge/__pycache__/desktop.ini

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

smartpaper_restore_bridge/frontend/index.html

@@ -19,6 +19,8 @@
   const MAX_TOKEN_LENGTH = 4096;
   const MAX_RESULT_AGE_MS = 10 * 60 * 1000;
   const REQUEST_TIMEOUT_MS = 20000;
+  const NAV_DIAG_KEY = "smartpaper.ui.navdiag.v1";
+  const NAV_DIAG_MAX_EVENTS = 24;
   const TERMINAL_TASK_STATUSES = new Set(["completed", "failed", "cancelled"]);
   let lastResponseSignature = "";
   let activeTaskWatch = null;
@@ -32,6 +34,86 @@
     target:{ authoritative:"", displayed:"", queue:[], timer:null }
   };
 
+
+  function readSessionJson(key, fallback=null) {
+    try {
+      const raw = window.sessionStorage.getItem(key);
+      return raw ? JSON.parse(raw) : fallback;
+    } catch (_) { return fallback; }
+  }
+
+  function writeSessionJson(key, value) {
+    try { window.sessionStorage.setItem(key, JSON.stringify(value)); return true; }
+    catch (_) { return false; }
+  }
+
+  function navigationSnapshot() {
+    let timeOrigin = 0;
+    let navigationType = "unknown";
+    try {
+      const perf = window.parent && window.parent.performance ? window.parent.performance : window.performance;
+      timeOrigin = Number(perf.timeOrigin || 0);
+      const entries = perf.getEntriesByType ? perf.getEntriesByType("navigation") : [];
+      if (entries && entries[0] && entries[0].type) navigationType = String(entries[0].type);
+    } catch (_) {
+      try {
+        timeOrigin = Number(window.performance.timeOrigin || 0);
+        const entries = window.performance.getEntriesByType("navigation");
+        if (entries && entries[0] && entries[0].type) navigationType = String(entries[0].type);
+      } catch (_) {}
+    }
+    return { time_origin:timeOrigin, navigation_type:navigationType };
+  }
+
+  function recordNavDiagnostic(kind, detail={}) {
+    const current = readSessionJson(NAV_DIAG_KEY, { version:1, mount_count:0, events:[] }) || { version:1, mount_count:0, events:[] };
+    if (!Array.isArray(current.events)) current.events = [];
+    const snapshot = navigationSnapshot();
+    current.last_time_origin = snapshot.time_origin;
+    current.navigation_type = snapshot.navigation_type;
+    current.events.push(Object.assign({
+      t:Date.now(), kind:String(kind || "event"), time_origin:snapshot.time_origin,
+      navigation_type:snapshot.navigation_type
+    }, detail && typeof detail === "object" ? detail : {}));
+    if (current.events.length > NAV_DIAG_MAX_EVENTS) current.events = current.events.slice(-NAV_DIAG_MAX_EVENTS);
+    writeSessionJson(NAV_DIAG_KEY, current);
+  }
+
+  function mountNavigationDiagnostics() {
+    const current = readSessionJson(NAV_DIAG_KEY, { version:1, mount_count:0, events:[] }) || { version:1, mount_count:0, events:[] };
+    current.mount_count = Number(current.mount_count || 0) + 1;
+    if (!Array.isArray(current.events)) current.events = [];
+    writeSessionJson(NAV_DIAG_KEY, current);
+    recordNavDiagnostic("bridge_mount", { mount_count:current.mount_count });
+    const add = (target, name, handler) => { try { target && target.addEventListener && target.addEventListener(name, handler); } catch (_) {} };
+    add(window, "pageshow", event => recordNavDiagnostic("pageshow", { persisted:!!event.persisted }));
+    add(window, "pagehide", event => recordNavDiagnostic("pagehide", { persisted:!!event.persisted }));
+    add(window, "online", () => recordNavDiagnostic("online"));
+    add(window, "offline", () => recordNavDiagnostic("offline"));
+    add(document, "visibilitychange", () => recordNavDiagnostic("visibilitychange", { state:String(document.visibilityState || "") }));
+    try {
+      const pw = window.parent;
+      add(pw, "pageshow", event => recordNavDiagnostic("parent_pageshow", { persisted:!!event.persisted }));
+      add(pw, "pagehide", event => recordNavDiagnostic("parent_pagehide", { persisted:!!event.persisted }));
+      add(pw, "online", () => recordNavDiagnostic("parent_online"));
+      add(pw, "offline", () => recordNavDiagnostic("parent_offline"));
+      if (pw.navigation && pw.navigation.addEventListener) {
+        add(pw.navigation, "navigate", event => recordNavDiagnostic("navigation", { navigation_type:String(event.navigationType || "") }));
+      }
+    } catch (_) {}
+  }
+
+  function navDiagnosticSnapshot() {
+    const current = readSessionJson(NAV_DIAG_KEY, { version:1, mount_count:0, events:[] }) || { version:1, mount_count:0, events:[] };
+    return {
+      version:1,
+      mount_count:Number(current.mount_count || 0),
+      last_time_origin:Number(current.last_time_origin || 0),
+      navigation_type:String(current.navigation_type || "unknown"),
+      events:Array.isArray(current.events) ? current.events.slice(-NAV_DIAG_MAX_EVENTS) : []
+    };
+  }
+
   const ACTION_PATHS = Object.freeze({
     task_start: "/edge/task/start",
     task_cancel: "/edge/task/cancel",
@@ -274,15 +356,63 @@
     target.textContent = value;
   }
 
+  const UNNUMBERED_HEADINGS = new Set([
+    "abstract","keywords","references","摘要","关键词","参考文献",
+    "аннотация","ключевые слова","литература","список литературы",
+    "аңдатпа","аннотация","түйінді сөздер","кілт сөздер","әдебиеттер","пайдаланылған әдебиеттер"
+  ]);
+
+  function cleanHeadingTitle(value) {
+    return String(value || "").trim().replace(/^\d+(?:\.\d+){0,2}\s+/, "");
+  }
+
+  function numberMarkdownHeadings(value) {
+    const text = String(value || "").replace(/\r/g, "");
+    const lines = text.split("\n");
+    const counters = [0,0,0];
+    const headingRows = lines.map((line, index) => {
+      const match = line.match(/^(#{1,3})\s+(.+?)\s*$/);
+      return match ? { index, level:match[1].length, title:cleanHeadingTitle(match[2]) } : null;
+    }).filter(Boolean);
+    const hasFrontMatter = headingRows.some(row => UNNUMBERED_HEADINGS.has(row.title.toLocaleLowerCase()));
+    const firstH1 = headingRows.find(row => row.level === 1);
+    for (const row of headingRows) {
+      const key = row.title.toLocaleLowerCase();
+      const isKnownUnnumbered = UNNUMBERED_HEADINGS.has(key);
+      const isTitle = hasFrontMatter && firstH1 && row.index === firstH1.index && !isKnownUnnumbered;
+      if (isKnownUnnumbered || isTitle) {
+        lines[row.index] = row.title;
+        continue;
+      }
+      if (row.level === 1) {
+        counters[0] += 1; counters[1] = 0; counters[2] = 0;
+        lines[row.index] = `${counters[0]} ${row.title}`;
+      } else if (row.level === 2) {
+        if (counters[0] === 0) counters[0] = 1;
+        counters[1] += 1; counters[2] = 0;
+        lines[row.index] = `${counters[0]}.${counters[1]} ${row.title}`;
+      } else {
+        if (counters[0] === 0) counters[0] = 1;
+        if (counters[1] === 0) counters[1] = 1;
+        counters[2] += 1;
+        lines[row.index] = `${counters[0]}.${counters[1]}.${counters[2]} ${row.title}`;
+      }
+    }
+    return lines.join("\n");
+  }
+
   function normalizePreviewDisplay(text) {
-    return String(text || "")
-      .replace(/\r/g, "")
-      .replace(/^#{1,3}\s+/gm, "");
+    return numberMarkdownHeadings(text);
   }
 
   function wordLikeUnits(value) {
-    const matches = String(value || "").match(/[\u4e00-\u9fff]{1,2}|\s+|[^\s\u4e00-\u9fff]+/g);
-    return matches || [];
+    const raw = String(value || "").match(/[\u4e00-\u9fff]{1,2}|[^\s\u4e00-\u9fff]+|\s+/g) || [];
+    const units = [];
+    for (const token of raw) {
+      if (/^\s+$/.test(token) && units.length) units[units.length - 1] += token;
+      else units.push(token);
+    }
+    return units;
   }
 
   function ensureStreamNode(parentDocument, target, channel) {
@@ -311,7 +441,7 @@
     if (!channel.queue.length) return;
     const stream = ensureStreamNode(parentDocument, target, channel);
     const backlog = channel.queue.length;
-    const perTick = backlog > 220 ? 3 : backlog > 90 ? 2 : 1;
+    const perTick = backlog > 500 ? 2 : 1;
     let chunk = "";
     for (let i=0; i<perTick && channel.queue.length; i++) chunk += channel.queue.shift();
     if (chunk) {
@@ -319,7 +449,7 @@
       channel.displayed += chunk;
       if (shell && shell.dataset.spAutoFollow !== "0") shell.scrollTop = shell.scrollHeight;
     }
-    channel.timer = window.setTimeout(() => pumpRenderQueue(parentDocument, target, shell, channel), 60);
+    channel.timer = window.setTimeout(() => pumpRenderQueue(parentDocument, target, shell, channel), 100);
   }
 
   function renderBufferedPreview(parentDocument, target, shell, text, channel) {
@@ -528,6 +658,7 @@
     const bestEffortPageExitCancel = payload.best_effort_page_exit_cancel === true;
     const watch = { commandId, taskId, apiOrigin, intervalMs, previewIntervalMs, previewUrl:resolvedPreviewUrl, expectedEpoch, draftStatusLabels, targetStatusLabels, bestEffortPageExitCancel, timer:null, previewTimer:null, controller:null, stopped:false, lastCheckpointSeq:initialCheckpointSeq };
     activeTaskWatch = watch;
+    recordNavDiagnostic("task_watch_start");
     installPageExitCancel(watch);
     lastPreviewText = "";
     lastTargetPreviewText = "";
@@ -562,12 +693,14 @@
           watch.stopped = true;
           activeTaskWatch = null;
           removePageExitCancel();
+          recordNavDiagnostic("task_watch_boundary", { status });
           sendValue(Object.assign({}, result, {
             action:"task_watch",
             command_id:commandId,
             terminal:TERMINAL_TASK_STATUSES.has(status),
             boundary:true,
-            boundary_type:"terminal"
+            boundary_type:"terminal",
+            ui_navdiag:navDiagnosticSnapshot()
           }));
           return;
         }
@@ -624,6 +757,7 @@
     sendValue(response);
   }
 
+  mountNavigationDiagnostics();
   window.addEventListener("message", onRender);
   sendMessage("streamlit:componentReady", { apiVersion:1 });
   setFrameHeight();

utils/__pycache__/desktop.ini

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