Step 4A-6-C-R3.2.8.5-R1.2 CAR Writing Quality + Nonfatal Word-Count Diagnostics + Content Sufficiency Gate

.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

config.py

@@ -326,10 +326,16 @@ def load_config():
             },
         ],
         "manuscript_validation": {
+            # Word counts are planning/quality diagnostics only. They must never
+            # independently fail an otherwise complete manuscript.
             "minimum_total_ratio": 0.97,
             "maximum_total_ratio": 1.03,
+            "total_short_notice_ratio": 0.70,
+            "total_topic_review_ratio": 0.50,
             "minimum_section_words": 120,
             "minimum_conclusion_words": 120,
+            "section_short_notice_ratio": 0.60,
+            "section_topic_review_ratio": 0.40,
             "minimum_qualitative_themes": 3,
             "minimum_qualitative_quotes": 8,
         },
@@ -427,7 +433,7 @@ Literature Metadata:
 4. ACADEMIC HEDGING: Use strategic hedging (e.g., 'This suggests a tendency toward X, bounded by Y').
 5. NO SWEEPING GENERALIZATIONS: Every sentence must carry specific theoretical weight or empirical fact.
 6. MECHANISM WITHOUT OVERCLAIMING: Articulate the theoretical mechanism precisely, but use causal wording only when the research design and frozen evidence justify causal identification.
-7. ACADEMIC REGISTER: Use concise, accurate, and rigorous language. Concepts must be explicit, hierarchy clear, and reasoning logically traceable.
+7. ACADEMIC REGISTER: Follow CAR: Conciseness, Accuracy, and Rigor. Concepts must be explicit, hierarchy clear, and reasoning logically traceable. Word-count allocations are planning targets, not content quotas: never add repetition, unsupported claims, generic filler, or unnecessary detail merely to hit a target.
 8. PROHIBITED RHETORIC: Never use metaphors, analogies, rhetorical questions, literary embellishment, or promotional claims.
 9. ABSTRACT DISCIPLINE: In abstracts, report only the minimum numerical evidence needed to convey the main finding; do not crowd the abstract with coefficients or test statistics.
 10. STRUCTURAL DISCIPLINE: Cover only the assigned section and subsection. Do not recreate earlier sections, invent alternative headings, or omit required analytical elements.
@@ -455,7 +461,7 @@ Literature Metadata:
 3. ACTOR/PROCESS LOGIC: Follow interpretation, action, coordination, sequence, comparison, or change as the selected analytic design and evidence warrant. Do not force a sensemaking lens onto every qualitative study.
 4. NO FORMAL HYPOTHESES: Do not use formal hypothesis testing. Use a research question, process/model explanation, or propositions only when the selected qualitative design and evidence warrant them.
 5. NO AI CLICHES: Strictly avoid 'delve', 'tapestry', 'multifaceted', 'beacon', 'landscape'.
-6. ACADEMIC REGISTER: Use concise, accurate, and rigorous language with explicit concepts and logically ordered claims.
+6. ACADEMIC REGISTER: Follow CAR: Conciseness, Accuracy, and Rigor, with explicit concepts and logically ordered claims. Word-count allocations are planning targets, not content quotas: never add repetition, unsupported claims, generic filler, or unnecessary detail merely to hit a target.
 7. PROHIBITED RHETORIC: Never use metaphors, analogies, rhetorical questions, literary embellishment, or promotional claims. Use concrete evidence-based description rather than decorative prose.
 8. ABSTRACT DISCIPLINE: Keep numerical details to the minimum needed to communicate the empirical puzzle, main finding, and contribution.
 9. CLAIM-SPECIFIC CITATION: Each sentence may contain at most one [CITE-XX] tag. Never group multiple references in one parenthesis or sentence. Separate distinct source-supported claims into separate sentences; when sources support the same claim, retain only the single most direct source. Every cited sentence must express a claim directly supported by the cited source evidence.""",

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:5ff1e1c8ae14f93f19fb2d92015df442e858db9e6cf8deccff732c4e0c8b1973
+size 273806

core/generation_runner.py

@@ -332,16 +332,95 @@ class GenerationRunner:
         # Markdown punctuation is ignored; contractions/hyphenated terms stay one token.
         return len(re.findall(r"\b[A-Za-z0-9]+(?:[-'][A-Za-z0-9]+)*\b", body))
 
-    def _validate_target_length(self, manuscript: str, target_words: int) -> None:
+    def _validate_target_length(self, manuscript: str, target_words: int) -> dict[str, Any]:
+        """Return a nonfatal total-length quality diagnostic.
+
+        The user-selected target remains a planning input, not a completion gate.
+        Completeness is validated separately by structure, evidence, citation,
+        translation, DOCX, and ZIP checks.
+        """
         quality = APP_CONFIG.get("manuscript_validation", {})
         minimum = int(target_words * float(quality.get("minimum_total_ratio", 0.97)))
         maximum = int(target_words * float(quality.get("maximum_total_ratio", 1.03)))
+        short_notice = float(quality.get("total_short_notice_ratio", 0.70))
+        topic_review = float(quality.get("total_topic_review_ratio", 0.50))
         actual = self._english_count_for_target(manuscript)
-        if actual < minimum or actual > maximum:
-            raise RuntimeError(
-                f"English manuscript length outside validated range: actual={actual}, "
-                f"required={minimum}-{maximum}, target={target_words}."
+        ratio = (actual / max(1, int(target_words)))
+        status = "normal"
+        recommendation = ""
+        if ratio < topic_review:
+            status = "very_short"
+            recommendation = (
+                "First verify that generation completed normally and no section/evidence is missing. "
+                "If the manuscript is complete, consider broadening the research scope or selecting a new research topic."
+            )
+        elif ratio < short_notice:
+            status = "short"
+            recommendation = (
+                "If the manuscript is structurally complete, consider broadening the theoretical scope, context, "
+                "research question, or research topic."
             )
+        elif actual < minimum:
+            status = "slightly_short"
+        elif actual > maximum:
+            status = "long"
+        if status != "normal":
+            logging.warning(
+                "Manuscript length diagnostic | actual=%s | target=%s | ratio=%.3f | status=%s | nonfatal=true",
+                actual, target_words, ratio, status,
+            )
+        return {
+            "scope": "manuscript", "name": "English manuscript", "actual_words": actual,
+            "target_words": int(target_words), "ratio": round(ratio, 4), "status": status,
+            "recommendation": recommendation, "nonfatal": True,
+        }
+
+    @staticmethod
+    def _upsert_quality_diagnostic(items: list[dict[str, Any]], diagnostic: dict[str, Any]) -> None:
+        key = (str(diagnostic.get("scope") or ""), str(diagnostic.get("name") or ""))
+        items[:] = [
+            item for item in items
+            if (str(item.get("scope") or ""), str(item.get("name") or "")) != key
+        ]
+        items.append(dict(diagnostic))
+
+    def _section_word_diagnostic(self, name: str, actual_words: int, target_words: int) -> dict[str, Any]:
+        validation = APP_CONFIG.get("manuscript_validation", {})
+        budget = APP_CONFIG.get("word_budget", {})
+        target = max(1, int(target_words))
+        actual = max(0, int(actual_words))
+        ratio = actual / target
+        short_notice = float(validation.get("section_short_notice_ratio", 0.60))
+        topic_review = float(validation.get("section_topic_review_ratio", 0.40))
+        preferred_min = float(budget.get("section_min_ratio", 0.92))
+        preferred_max = float(budget.get("section_max_ratio", 1.08))
+        status = "normal"
+        recommendation = ""
+        if ratio < topic_review:
+            status = "very_short"
+            recommendation = (
+                "First verify that this section completed normally and that evidence was available. "
+                "If it is complete, consider broadening the research scope or selecting a new research topic."
+            )
+        elif ratio < short_notice:
+            status = "short"
+            recommendation = (
+                "If the section is complete, consider broadening the theoretical scope, context, research question, "
+                "or research topic."
+            )
+        elif ratio < preferred_min:
+            status = "slightly_short"
+        elif ratio > preferred_max:
+            status = "long"
+        if status != "normal":
+            logging.warning(
+                "Section length diagnostic | section=%s | actual=%s | target=%s | ratio=%.3f | status=%s | nonfatal=true",
+                name, actual, target, ratio, status,
+            )
+        return {
+            "scope": "section", "name": str(name), "actual_words": actual, "target_words": target,
+            "ratio": round(ratio, 4), "status": status, "recommendation": recommendation, "nonfatal": True,
+        }
 
     def _resolve_paths(self, items) -> list[str]:
         output = []
@@ -383,6 +462,7 @@ class GenerationRunner:
         qual_engine = get_qualitative_engine(agent)
 
         state = self.checkpoints.load_latest() or {}
+        quality_diagnostics = list(state.get("quality_diagnostics") or [])
         if state:
             self._preview_english_text = str(state.get('full_draft_en') or '')
             self._preview_target_text = str(state.get('full_draft_translated') or '')
@@ -646,7 +726,7 @@ class GenerationRunner:
                 raise RuntimeError("task_cancel_requested")
             remaining = sum(1 for item in adaptive_structure if item["display_name"] not in completed_sections)
             adjusted_target = self._bounded_target(
-                int(sec["target_words"]), accumulated_deviation, remaining, safe_chunk_words
+                int(sec["target_words"]), 0.0, remaining, safe_chunk_words
             )
             sec_title = sec["section"]
             subsection = sec.get("subsection")
@@ -745,7 +825,7 @@ Section: {sec_title}
 Subsection: {subsection or 'None'}
 Section reasoning role: {section_role}
 Additional mode directive: {mode_directive}
-Target length: {int(adjusted_target * min_ratio)}-{int(adjusted_target * max_ratio)} words.
+Planning length: approximately {int(adjusted_target * min_ratio)}-{int(adjusted_target * max_ratio)} words. This is guidance, not a content quota. Prioritize Conciseness, Accuracy, and Rigor; never add filler or remove useful reasoning solely to hit the range.
 {heading_directive}
 {citation_rule}
 {table_rule}
@@ -849,6 +929,9 @@ Output only final academic prose. Do not report the word count."""
             context_tail = " ".join(en_raw.split()[-200:])
             actual_words = self._english_count_for_target(en_resolved)
             accumulated_deviation += actual_words - adjusted_target
+            self._upsert_quality_diagnostic(
+                quality_diagnostics, self._section_word_diagnostic(display_name, actual_words, adjusted_target)
+            )
             completed_sections.append(display_name)
             section_key = str(sec.get('section_id') or sec_title)
             if self._section_is_complete(adaptive_structure, completed_sections, section_key):
@@ -869,6 +952,7 @@ Output only final academic prose. Do not report the word count."""
                     "translation_glossary": translation_glossary,
                     "context_tail": context_tail,
                     "accumulated_deviation": accumulated_deviation,
+                    "quality_diagnostics": quality_diagnostics,
                     "agent_state": agent.export_state(),
                     "data_metadata": data_metadata,
                 }
@@ -900,13 +984,9 @@ Output only final academic prose. Do not report the word count."""
                 )
             full_draft_en = full_draft_en.rstrip() + "\n\n# References\n" + "\n\n".join(references)
             actual_words = self._english_count_for_target(full_draft_en)
-            quality = APP_CONFIG.get("manuscript_validation", {})
-            minimum_words = int(target_words * float(quality.get("minimum_total_ratio", 0.97)))
-            maximum_words = int(target_words * float(quality.get("maximum_total_ratio", 1.03)))
-            if actual_words < minimum_words or actual_words > maximum_words:
-                full_draft_en = agent.rebalance_discussion_length(
-                    full_draft_en, target_words=target_words, mode=mode, actual_words=actual_words
-                )
+            self._upsert_quality_diagnostic(
+                quality_diagnostics, self._validate_target_length(full_draft_en, target_words)
+            )
             body_only, _reference_tail = agent.validate_reference_tail(
                 full_draft_en, minimum_references=MIN_FINAL_REFERENCES
             )
@@ -931,7 +1011,9 @@ 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)
-            self._validate_target_length(full_draft_en, target_words)
+            self._upsert_quality_diagnostic(
+                quality_diagnostics, 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
@@ -958,6 +1040,7 @@ Output only final academic prose. Do not report the word count."""
                     "final_abstract": final_abstract,
                     "final_keywords": final_keywords,
                     "front_matter_phase": "final",
+                    "quality_diagnostics": quality_diagnostics,
                     "english_finalized": True,
                     "translation_complete": False,
                     "agent_state": agent.export_state(),
@@ -1041,6 +1124,7 @@ Output only final academic prose. Do not report the word count."""
             mode=mode,
             citation_audit=agent.citation_audit_log,
             literature_metrics=agent.get_source_metrics(),
+            quality_diagnostics=quality_diagnostics,
         )
         output_filename = f"SmartPaper_{bj_time}.zip"
         pending = self.output_dir / (".pending_" + output_filename)

core/pipeline_agent.py

@@ -1257,14 +1257,35 @@ Return a concise PROVISIONAL RESEARCH LOGIC CONTRACT in plain English prose. It
             or re.search(r'\([^()\n]*?(?:19|20)\d{2}[a-z]?[^()\n]*?\)', text, flags=re.I)
         )
 
+    @staticmethod
+    def _working_abstract_word_count(value):
+        return len(re.findall(r"\b[A-Za-z0-9]+(?:[-'][A-Za-z0-9]+)*\b", str(value or '')))
+
+    @classmethod
+    def _trim_working_abstract_overflow(cls, text, maximum=180, minimum=80):
+        """Trim only a small overflow at a complete sentence boundary."""
+        sentences = [part.strip() for part in re.split(r'(?<=[.!?])\s+', str(text or '').strip()) if part.strip()]
+        kept = []
+        for sentence in sentences:
+            candidate = ' '.join(kept + [sentence]).strip()
+            if cls._working_abstract_word_count(candidate) > maximum:
+                break
+            kept.append(sentence)
+        trimmed = ' '.join(kept).strip()
+        count = cls._working_abstract_word_count(trimmed)
+        if minimum <= count <= maximum:
+            return trimmed
+        raise DeepSeekRequestError(
+            f'Working Abstract overflow could not be safely trimmed to {minimum}-{maximum} English words at a sentence boundary.'
+        )
+
     @classmethod
     def _validate_working_abstract(cls, value):
+        """Validate semantic safety; word count is quality guidance, never a fatal gate."""
         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 not text:
+            raise DeepSeekRequestError('Working Abstract is empty.')
+        word_count = cls._working_abstract_word_count(text)
         if cls._front_matter_has_citation(text):
             raise DeepSeekRequestError('Working Abstract must not contain citations.')
         forbidden = (
@@ -1277,6 +1298,11 @@ Return a concise PROVISIONAL RESEARCH LOGIC CONTRACT in plain English prose. It
         )
         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.')
+        if word_count < 80 or word_count > 180:
+            logging.warning(
+                'Working Abstract length diagnostic | words=%s | preferred=80-180 | nonfatal=true',
+                word_count,
+            )
         return text
 
     def generate_working_front_matter(
@@ -1288,7 +1314,7 @@ Return a concise PROVISIONAL RESEARCH LOGIC CONTRACT in plain English prose. It
         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.
+Aim for approximately 120-180 English words, have no citations, and function only as a continuity anchor. Word count is guidance, not a failure condition; prioritize Conciseness, Accuracy, and Rigor over mechanical compliance. 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}
@@ -1318,7 +1344,7 @@ USER KEYWORD SEEDS: {keywords}
         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.
+Aim for a concise Abstract of roughly 120-200 words, use no citations, and accurately state the research problem, validated design, main frozen finding(s), and contribution. Word count is guidance, not a failure condition; prioritize Conciseness, Accuracy, and Rigor. 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}
@@ -1342,9 +1368,14 @@ USER KEYWORD SEEDS: {keywords}
         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.')
+        if not abstract:
+            raise DeepSeekRequestError('Final Abstract is empty after validation.')
+        final_word_count = self._working_abstract_word_count(abstract)
+        if final_word_count < 80 or final_word_count > max_words:
+            logging.warning(
+                'Final Abstract length diagnostic | words=%s | preferred=80-%s | nonfatal=true',
+                final_word_count, max_words,
+            )
         final_keywords = self._front_matter_keywords(parsed.get('keywords'))
         return {'abstract': abstract, 'keywords': final_keywords}
 
@@ -1544,7 +1575,10 @@ USER KEYWORD SEEDS: {keywords}
                 count = len(match.group(1).split())
                 required = minimum_conclusion if title == "Conclusion" else minimum_words
                 if count < required:
-                    errors.append(f"section {title!r} has {count} words; required>={required}")
+                    logging.warning(
+                        "Manuscript section length diagnostic | section=%s | words=%s | reference_min=%s | nonfatal=true",
+                        title, count, required,
+                    )
 
         if errors:
             raise DeepSeekAPIError(
@@ -3195,64 +3229,6 @@ Output only the repaired section."""
         logging.info('Top-journal local repair accepted: section=%s issue=%s', section_name, instruction[:180])
         return self._remove_ai_meta_traces(revised)
 
-    def rebalance_discussion_length(self, manuscript, *, target_words, mode, actual_words):
-        """Use Discussion as the bounded final word-budget correction surface."""
-        value = str(manuscript or '')
-        delta = int(target_words) - int(actual_words)
-        if abs(delta) < 40:
-            return value
-        match = re.search(r'(?ms)^#\s+Discussion\s*$\n(.*?)(?=^#\s+[^#].*?$|\Z)', value)
-        if not match:
-            return value
-        original = match.group(1).strip()
-        if len(original.split()) < 200:
-            return value
-        action = 'expand' if delta > 0 else 'compress'
-        requested = min(abs(delta), max(120, int(len(original.split()) * 0.28)))
-        prompt = f"""{action.capitalize()} this Discussion section by approximately {requested} words so the completed manuscript approaches its requested total length.
-Preserve every heading, number, resolved author-year citation, quotation, hypothesis label, variable abbreviation, and conclusion direction. Do not add new empirical facts, sources, statistics, quotations, or methods. If expanding, deepen mechanism, theoretical boundary, and interpretation already supported by the section. If compressing, remove repetition and low-information phrasing without deleting a substantive finding or citation.
-MODE: {mode}
-TEXT:
-{original}
-Output only the revised Discussion body, without the '# Discussion' heading."""
-        revised = self.call_deepseek(
-            'You are a precise top-journal length editor.', prompt,
-            max_tokens=max(1800, min(8000, self._count_tokens(original) + max(800, requested * 2))),
-            temp=0.1, model_role='writing', thinking=False, allow_fallback=False,
-        ).strip()
-        if self._numeric_tokens(original) != self._numeric_tokens(revised):
-            logging.warning('Word-budget Discussion repair rejected because numbers changed.')
-            return value
-        cite_pattern = r'\([^()\n]*?(?:19|20)\d{2}[a-z]?[^()\n]*?\)'
-        if Counter(re.findall(cite_pattern, original, re.I)) != Counter(re.findall(cite_pattern, revised, re.I)):
-            logging.warning('Word-budget Discussion repair rejected because citations changed.')
-            return value
-        if self.find_multi_citation_violations(revised):
-            logging.warning('Word-budget Discussion repair rejected because it stacked multiple sources in one sentence.')
-            return value
-        return value[:match.start(1)] + revised + '\n\n' + value[match.end(1):]
-
-    @staticmethod
-    def _trim_at_sentence_boundary(value, max_words):
-        text = str(value or '').strip()
-        words = text.split()
-        if len(words) <= max_words:
-            return text
-        sentences = re.split(r'(?<=[.!?])\s+', text)
-        selected = []
-        count = 0
-        for sentence in sentences:
-            sentence_words = sentence.split()
-            if not sentence_words:
-                continue
-            if count + len(sentence_words) > max_words:
-                break
-            selected.append(sentence.strip())
-            count += len(sentence_words)
-        if selected:
-            return ' '.join(selected).strip()
-        return ' '.join(words[:max_words]).rstrip(' ,;:') + '.'
-
     def _abstract_manuscript_context(self, manuscript, max_tokens=18000):
         value = str(manuscript or '').strip()
         if self._count_tokens(value) <= max_tokens:

core/production_guard.py

@@ -116,6 +116,39 @@ def build_generation_notes(data_metadata: dict[str, Any], mode: str) -> str:
     return "\n".join(lines).strip() + "\n"
 
 
+
+def build_word_count_quality_report(diagnostics: list[dict[str, Any]] | None) -> str:
+    """Human-readable, nonfatal word-count guidance for the author."""
+    items = [dict(item) for item in (diagnostics or []) if isinstance(item, dict)]
+    lines = [
+        "SmartPaper Word-Count Quality Report",
+        "",
+        "Policy: Word-count targets are planning guidance, not success/failure gates.",
+        "Writing quality is governed by CAR: Conciseness, Accuracy, and Rigor.",
+        "Long sections are not truncated merely to satisfy a target. Short sections are diagnosed before any topic recommendation.",
+        "",
+    ]
+    flagged = [item for item in items if str(item.get("status") or "normal") != "normal"]
+    if not flagged:
+        lines.append("No material word-count deviation was detected.")
+    else:
+        lines.append("Diagnostics:")
+        for item in flagged:
+            actual = item.get("actual_words")
+            target = item.get("target_words")
+            status = str(item.get("status") or "")
+            name = str(item.get("name") or item.get("scope") or "Manuscript")
+            lines.append(f"- {name}: actual={actual}, planning target={target}, status={status}. Generation continued normally.")
+            recommendation = str(item.get("recommendation") or "").strip()
+            if recommendation:
+                lines.append(f"  Author guidance: {recommendation}")
+    lines.extend([
+        "",
+        "Interpretation note:",
+        "A short section does not by itself prove that the research topic is unsuitable. It may reflect a narrow topic, limited evidence, a deliberately concise argument, or an incomplete generation step. Verify completeness first. If multiple core sections remain substantially short despite complete generation and adequate evidence, broaden the scope or consider selecting a new research topic.",
+    ])
+    return "\n".join(lines).strip() + "\n"
+
 def _manifest(entries: dict[str, bytes]) -> str:
     rows = []
     for name in sorted(entries):
@@ -133,6 +166,7 @@ def build_validated_package(
     mode: str,
     citation_audit: list[dict[str, Any]],
     literature_metrics: dict[str, Any],
+    quality_diagnostics: list[dict[str, Any]] | None = None,
 ) -> PackageResult:
     validate_markdown_manuscript(english_markdown, language_name="English")
     validate_markdown_manuscript(translated_markdown, language_name="Target-language")
@@ -151,6 +185,7 @@ def build_validated_package(
         "GENERATION_NOTES.txt": build_generation_notes(data_metadata, mode).encode("utf-8"),
         "CITATION_AUDIT.json": json.dumps(citation_audit or [], ensure_ascii=False, indent=2).encode("utf-8"),
         "LITERATURE_METRICS.json": json.dumps(literature_metrics or {}, ensure_ascii=False, indent=2).encode("utf-8"),
+        "WORD_COUNT_QUALITY_REPORT.txt": build_word_count_quality_report(quality_diagnostics).encode("utf-8"),
     }
     manifest = _manifest(entries)
     entries["FILE_MANIFEST_SHA256.txt"] = manifest.encode("utf-8")

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