R3.2.8.6-R1.3C-KK1-R6A-R3 Qualitative Appendix Citation Relevance and Quote Output Integrity Final Fix

config.py

@@ -196,7 +196,8 @@ def load_config():
                 "reference", "references", "reference list", "参考文献", 
                 "acknowledgment", "acknowledgements", "致谢",
                 "аннотация", "ключевые слова", "аңдатпа", "түйіндеме",
-                "түйін сөздер", "түйінді сөздер", "кілт сөздер"
+                "түйін сөздер", "түйінді сөздер", "кілт сөздер",
+                "appendix", "附录", "приложение", "қосымша"
             ]
         },
 

core/generation_runner.py

@@ -183,6 +183,7 @@ class GenerationRunner:
         self._translation_worker_collected = 0
         self._translation_worker_pending = set()
         self._translation_worker_context = {}
+        self._qualitative_quote_sources = {}
         if self.preview_token:
             preview_dir = Path(__file__).resolve().parents[1] / "static" / "previews"
             preview_dir.mkdir(parents=True, exist_ok=True)
@@ -345,7 +346,8 @@ class GenerationRunner:
                 raise RuntimeError(f"Qualitative quotation already used before owning unit: {tag}")
 
         for tag in sorted(allowed):
-            count = len(re.findall(rf"\b{re.escape(tag)}\b", value))
+            tag_pattern = rf"(?<!\w)\[?{re.escape(tag)}\]?(?!\w)"
+            count = len(re.findall(tag_pattern, value))
             if count > 1:
                 raise RuntimeError(
                     f"Qualitative quotation repeated within owning Findings unit: {tag} count={count}"
@@ -353,7 +355,7 @@ class GenerationRunner:
             if count == 1:
                 quote = str((evidence_by_tag.get(tag) or {}).get("quote") or "").strip()
                 value = re.sub(
-                    rf"\b{re.escape(tag)}\b",
+                    tag_pattern,
                     lambda _match, frozen_quote=quote: f'"{frozen_quote}"',
                     value,
                     count=1,
@@ -365,6 +367,84 @@ class GenerationRunner:
             raise RuntimeError(f"Unresolved qualitative quotation tags: {unresolved[:8]}")
         return value
 
+    @staticmethod
+    def _qualitative_quote_source_map(data_metadata):
+        return {
+            str(item.get("tag") or "").strip(): str(item.get("quote") or "").strip()
+            for item in (data_metadata or {}).get("evidence", [])
+            if isinstance(item, dict)
+            and str(item.get("tag") or "").strip()
+            and str(item.get("quote") or "").strip()
+        }
+
+    @classmethod
+    def _prepare_qualitative_translation_source(cls, source, quote_sources, quote_ledger):
+        """Use one task-level target rendering for every frozen qualitative quote.
+
+        The first translated occurrence keeps the English quote in context and
+        appends its protected QUOTE tag so the target rendering can be captured.
+        Later occurrences (notably the Appendix) send only the protected tag and
+        are restored from the already QA-passed task-level quote ledger.
+        """
+        value = str(source or "")
+        pending = []
+        reused = []
+        for tag, quote in sorted((quote_sources or {}).items()):
+            wrapped = f'"{quote}"'
+            tagged = f'{wrapped} [{tag}]'
+            if tagged in value:
+                if tag in (quote_ledger or {}):
+                    value = value.replace(tagged, f"[{tag}]")
+                    reused.append(tag)
+                else:
+                    pending.append(tag)
+                continue
+            if wrapped not in value:
+                continue
+            if tag in (quote_ledger or {}):
+                value = value.replace(wrapped, f"[{tag}]")
+                reused.append(tag)
+            else:
+                value = value.replace(wrapped, tagged)
+                pending.append(tag)
+        return value, pending, reused
+
+    @classmethod
+    def _finalize_qualitative_translation_quotes(cls, translated, pending, reused, quote_ledger):
+        value = str(translated or "")
+        ledger = dict(quote_ledger or {})
+        quote_pattern = r'(?P<quote>"[^"\n]{4,2500}"|“[^”\n]{4,2500}”|«[^»\n]{4,2500}»|„[^“\n]{4,2500}“)' 
+        for tag in pending or []:
+            pattern = re.compile(
+                quote_pattern + rf"\s*(?<!\w)\[?{re.escape(tag)}\]?(?!\w)",
+                flags=re.UNICODE,
+            )
+            matches = list(pattern.finditer(value))
+            if len(matches) != 1:
+                raise RuntimeError(
+                    f"Qualitative quote translation ledger capture failed: {tag} matches={len(matches)}"
+                )
+            rendered_quote = matches[0].group("quote")
+            ledger[tag] = rendered_quote
+            value = value[:matches[0].start()] + rendered_quote + value[matches[0].end():]
+
+        for tag in reused or []:
+            rendered_quote = str(ledger.get(tag) or "").strip()
+            if not rendered_quote:
+                raise RuntimeError(f"Qualitative quote translation ledger missing target text: {tag}")
+            pattern = rf"(?<!\w)\[?{re.escape(tag)}\]?(?!\w)"
+            count = len(re.findall(pattern, value))
+            if count != 1:
+                raise RuntimeError(
+                    f"Qualitative quote translation ledger reuse failed: {tag} matches={count}"
+                )
+            value = re.sub(pattern, lambda _m, q=rendered_quote: q, value, count=1)
+
+        unresolved = sorted(set(re.findall(r"\bQUOTE-\d+\b", value)))
+        if unresolved:
+            raise RuntimeError(f"Unresolved target-language qualitative quote tags: {unresolved[:8]}")
+        return value, ledger
+
     def _write_preview_payload(self, *, force: bool = False) -> None:
         with self._preview_lock:
             if self.preview_path is None:
@@ -642,6 +722,15 @@ class GenerationRunner:
             english_commit_text=english_commit_text,
         )
         updated_sections = dict(translation_sections or {})
+        quote_ledger_record = dict(updated_sections.get("__quote_ledger__") or {})
+        quote_ledger = (
+            dict(quote_ledger_record.get("translations") or {})
+            if quote_ledger_record.get("target_lang") in {None, "", target_lang}
+            else {}
+        )
+        translation_source, pending_quote_tags, reused_quote_tags = self._prepare_qualitative_translation_source(
+            source, getattr(self, "_qualitative_quote_sources", {}), quote_ledger
+        )
 
         def publish_translation_stage(stage):
             value = str(stage or '').strip().casefold()
@@ -669,7 +758,20 @@ class GenerationRunner:
                 supports_stage_callback = False
             if supports_stage_callback:
                 call_kwargs['stage_callback'] = publish_translation_stage
-            result = translate_method(source, target_lang, **call_kwargs)
+            result = translate_method(translation_source, target_lang, **call_kwargs)
+            translated_text = str(result.get('text') or '').strip()
+            if pending_quote_tags or reused_quote_tags:
+                translated_text, quote_ledger = self._finalize_qualitative_translation_quotes(
+                    translated_text, pending_quote_tags, reused_quote_tags, quote_ledger
+                )
+                agent.validate_translation_alignment(source, translated_text)
+                result = dict(result)
+                result['text'] = translated_text
+                updated_sections['__quote_ledger__'] = {
+                    'target_lang': target_lang,
+                    'translations': dict(quote_ledger),
+                    'updated_at': datetime.now(timezone.utc).isoformat(),
+                }
         except PipelineCancelledError:
             raise
         except Exception as error:
@@ -923,6 +1025,10 @@ class GenerationRunner:
             )
             self._checkpoint("evidence_ready", state, 6)
 
+        self._qualitative_quote_sources = (
+            self._qualitative_quote_source_map(data_metadata) if mode == "asq" else {}
+        )
+
         # ASQ planning never needs access to verbatim quotations.  Keep the
         # research-logic/front-matter stage on a quote-free internal-evidence
         # summary; verbatim text is disclosed later only to its owning Findings
@@ -1400,8 +1506,20 @@ Output only final academic prose. Do not report the word count."""
                         if str(item.get("tag") or "") not in used_after
                     ]
                     needed = max(0, required_survival - len(survived))
+                    recovery_items = agent.select_contextual_citation_recovery_items(
+                        missing_items, section_name=display_name, section_context=en_resolved,
+                        needed=needed, excluded_tags=used_after,
+                    )
+                    if len(recovery_items) < needed:
+                        recovery_items.extend(
+                            agent.fetch_contextual_jit_recovery_items(
+                                topic=topic, section_name=display_name, section_context=en_resolved,
+                                needed=needed - len(recovery_items),
+                                excluded_tags=used_after | {str(item.get("tag") or "") for item in recovery_items},
+                            )
+                        )
                     supplemental_raw = agent.build_citation_recovery_paragraph(
-                        missing_items[:needed], section_name=display_name
+                        recovery_items[:needed], section_name=display_name, section_context=en_resolved
                     )
                     if supplemental_raw:
                         supplemental_resolved = agent.audit_and_resolve_citations(
@@ -1423,10 +1541,11 @@ Output only final academic prose. Do not report the word count."""
             agent._extract_memory_from_text(en_raw, sec_title)
             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)
-            )
+            if not bool(sec.get("exclude_from_word_budget")):
+                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):

core/pipeline_agent.py

@@ -2515,13 +2515,216 @@ INPUT:
                 lines.append(f"- {tag} SUPPORTED CLAIM: {claim}\n  EVIDENCE: {evidence}")
         return '\n'.join(lines)
 
-    def build_citation_recovery_paragraph(self, items, section_name=''):
+    _CITATION_RECOVERY_GENERIC_TERMS = frozenset({
+        'study','studies','research','data','analysis','analyses','model','models','learning',
+        'system','systems','method','methods','result','results','technology','technologies',
+        'education','educational','artificial','intelligence','application','applications',
+        'use','uses','used','using','user','users','approach','approaches','framework','frameworks',
+    })
+
+    @classmethod
+    def _citation_recovery_overlap(cls, section_name, section_context, claim, evidence):
+        anchor_terms = cls._citation_terms(f"{section_name} {section_context}")
+        candidate_terms = cls._citation_terms(f"{claim} {evidence}")
+        overlap_terms = anchor_terms & candidate_terms
+        distinctive = overlap_terms - cls._CITATION_RECOVERY_GENERIC_TERMS
+        return len(overlap_terms), len(distinctive)
+
+    @classmethod
+    def _citation_recovery_item_relevant(cls, item, section_name='', section_context=''):
+        if not str(section_context or '').strip():
+            return True
+        claim = str((item or {}).get('claim') or '')
+        evidence = str((item or {}).get('evidence') or '')
+        overlap, distinctive = cls._citation_recovery_overlap(
+            section_name, section_context, claim, evidence
+        )
+        return distinctive >= 2 or (distinctive >= 1 and overlap >= 3)
+
+    @classmethod
+    def _best_contextual_evidence_claim(cls, evidence, section_name='', section_context=''):
+        raw = re.sub(r'\s+', ' ', str(evidence or '')).strip()
+        if not raw:
+            return ''
+        abstract = raw.split('Abstract evidence:', 1)[-1].strip() if 'Abstract evidence:' in raw else raw
+        sentences = [part.strip() for part in re.split(r'(?<=[.!?])\s+', abstract) if 8 <= len(part.split()) <= 55]
+        ranked = []
+        for sentence in sentences:
+            overlap, distinctive = cls._citation_recovery_overlap(
+                section_name, section_context, sentence, raw
+            )
+            if distinctive >= 2 or (distinctive >= 1 and overlap >= 3):
+                ranked.append((distinctive, overlap, -len(sentence.split()), sentence))
+        if not ranked:
+            return ''
+        ranked.sort(reverse=True)
+        return ranked[0][3]
+
+    def select_contextual_citation_recovery_items(
+        self, items, *, section_name='', section_context='', needed=1, excluded_tags=None,
+    ):
+        """Select only recovery citations that are actually about the current unit.
+
+        First consider the unit's planned-but-unused items. If those are not
+        contextually relevant, draw from the already-retrieved evidence pool
+        using an abstract sentence copied verbatim as the narrow recovery claim.
+        This prevents quota-driven paragraphs about unrelated domains.
+        """
+        needed = max(0, int(needed or 0))
+        if needed <= 0:
+            return []
+        excluded = {str(tag or '').strip() for tag in (excluded_tags or set()) if str(tag or '').strip()}
+        ranked = []
+        seen = set()
+        for item in items or []:
+            if not isinstance(item, dict):
+                continue
+            tag = str(item.get('tag') or '').strip()
+            if not tag or tag in excluded or tag in seen:
+                continue
+            if not self._citation_recovery_item_relevant(item, section_name, section_context):
+                continue
+            overlap, distinctive = self._citation_recovery_overlap(
+                section_name, section_context, item.get('claim'), item.get('evidence')
+            )
+            ranked.append((distinctive, overlap, -self._citation_tag_number(tag), dict(item)))
+            seen.add(tag)
+        ranked.sort(reverse=True, key=lambda row: (row[0], row[1], row[2]))
+        selected = [row[3] for row in ranked[:needed]]
+        if len(selected) >= needed:
+            return selected
+
+        used = excluded | {str(item.get('tag') or '') for item in selected}
+        pool = []
+        for tag, meta in self.citation_map.items():
+            if tag in used:
+                continue
+            evidence = re.sub(r'\s+', ' ', str(meta.get('evidence') or '')).strip()
+            claim = self._best_contextual_evidence_claim(
+                evidence, section_name=section_name, section_context=section_context
+            )
+            if not claim:
+                continue
+            overlap, distinctive = self._citation_recovery_overlap(
+                section_name, section_context, claim, evidence
+            )
+            pool.append((distinctive, overlap, -self._citation_tag_number(tag), {
+                'tag': tag, 'claim': claim, 'evidence': evidence[:900],
+            }))
+        pool.sort(reverse=True, key=lambda row: (row[0], row[1], row[2]))
+        for _distinctive, _overlap, _order, item in pool:
+            selected.append(item)
+            if len(selected) >= needed:
+                break
+        return selected
+
+    def fetch_contextual_jit_recovery_items(
+        self, *, topic, section_name, section_context, needed=1, excluded_tags=None,
+    ):
+        """Bounded last-resort JIT top-up for a genuine section-specific citation gap.
+
+        At most one query is issued to each literature backend. New references
+        are admitted only when title/abstract evidence has distinctive lexical
+        overlap with the current manuscript unit; otherwise the final >=50 gate
+        is allowed to fail rather than padding the manuscript with irrelevant
+        literature.
+        """
+        needed = max(0, int(needed or 0))
+        if needed <= 0:
+            return []
+        excluded = {str(tag or '').strip() for tag in (excluded_tags or set()) if str(tag or '').strip()}
+        context_words = [
+            term for term in sorted(self._citation_terms(section_context))
+            if term not in self._CITATION_RECOVERY_GENERIC_TERMS
+        ][:12]
+        prompt = (
+            "Generate exactly one concise English academic search query of 3-5 terms. "
+            "It must target the named manuscript unit and must not introduce a different application domain. "
+            "Return only the query.\n"
+            f"Topic: {str(topic or '')[:300]}\nSection: {section_name}\n"
+            f"Context terms: {' '.join(context_words)}"
+        )
+        try:
+            query = self.call_deepseek(
+                'You are a precise academic librarian.', prompt, max_tokens=50, temp=0.1,
+                model_role='fast', thinking=False, allow_fallback=False,
+            ).strip(' "\'')
+            query = self._normalize_search_query(query)
+        except Exception as exc:
+            logging.warning('Contextual citation JIT query generation failed: section=%s error=%s', section_name, type(exc).__name__)
+            return []
+        if not query:
+            return []
+        logging.info('Contextual citation JIT: section=%s query=%r needed=%s', section_name, query, needed)
+        results = []
+        try:
+            with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
+                futures = [
+                    executor.submit(self._s2_worker, query, 0),
+                    executor.submit(self._oa_worker, query, 1, 'language:en,type:article,is_paratext:false'),
+                ]
+                for future in concurrent.futures.as_completed(futures):
+                    self._check_cancelled()
+                    results.extend(future.result())
+        except Exception as exc:
+            logging.warning('Contextual citation JIT retrieval failed: section=%s error=%s', section_name, type(exc).__name__)
+            return []
+
+        existing_keys = {
+            key for metadata in self.citation_map.values() for key in self._reference_keys(metadata)
+        }
+        candidates = []
+        staged_keys = set()
+        for res in results:
+            keys = self._reference_keys(res)
+            if keys and (any(key in existing_keys for key in keys) or any(key in staged_keys for key in keys)):
+                continue
+            evidence = re.sub(r'\s+', ' ', str(res.get('rag_text') or '')).strip()
+            claim = self._best_contextual_evidence_claim(
+                evidence, section_name=section_name, section_context=section_context
+            )
+            if not claim:
+                continue
+            overlap, distinctive = self._citation_recovery_overlap(
+                section_name, section_context, claim, evidence
+            )
+            candidates.append((distinctive, overlap, res, claim, evidence, keys))
+            staged_keys.update(keys)
+        candidates.sort(reverse=True, key=lambda row: (row[0], row[1]))
+        selected = []
+        with self.lock:
+            for _distinctive, _overlap, res, claim, evidence, keys in candidates:
+                tag = f"[CITE-{len(self.citation_map)+1:02d}]"
+                if tag in excluded:
+                    continue
+                self.citation_map[tag] = {
+                    'in_text': res.get('in_text', ''),
+                    'ref': res.get('ref', ''),
+                    'id': keys[0] if keys else ('title_year', res.get('title'), res.get('year')),
+                    'doi': res.get('doi', ''),
+                    'external_id': res.get('external_id', ''),
+                    'title': res.get('title', ''),
+                    'year': res.get('year', ''),
+                    'evidence': evidence,
+                    'sources': [res.get('source', 'jit')],
+                }
+                selected.append({'tag': tag, 'claim': claim, 'evidence': evidence[:900]})
+                if len(selected) >= needed:
+                    break
+        logging.info('Contextual citation JIT accepted: section=%s accepted=%s/%s', section_name, len(selected), needed)
+        return selected
+
+    def build_citation_recovery_paragraph(self, items, section_name='', section_context=''):
         """Create one bounded literature paragraph from already planned evidence.
 
         This is invoked only when semantic validation removed too many planned
         citations from a unit. It never invents new sources or study facts.
         """
-        selected = [item for item in (items or []) if item.get('tag') and item.get('claim') and item.get('evidence')][:5]
+        selected = [
+            item for item in (items or [])
+            if item.get('tag') and item.get('claim') and item.get('evidence')
+            and self._citation_recovery_item_relevant(item, section_name, section_context)
+        ][:5]
         if not selected:
             return ''
         plan_text = self.format_claim_evidence_plan(selected)
@@ -2788,13 +2991,14 @@ Return exactly:
             for technical_attempt in range(technical_retries):
                 self._check_cancelled()
                 try:
+                    compact_retry = technical_attempt > 0
                     response = self.call_deepseek(
                         system_prompt,
                         user_prompt,
-                        max_tokens=8000,
+                        max_tokens=3200 if compact_retry else 8000,
                         temp=0.0,
                         model_role="reasoning",
-                        thinking=True,
+                        thinking=not compact_retry,
                         allow_fallback=False,
                     )
                     parsed = self._extract_json_from_text(response)
@@ -2991,7 +3195,7 @@ Return exactly:
         coverage = overlap / max(1, len(claim_terms))
         return coverage, overlap
 
-    def _local_citation_recovery(self, text, section_name=''):
+    def _local_citation_recovery(self, text, section_name='', retain_lexical=True):
         """Conservative deterministic recovery for technical audit failures.
 
         This routine never keeps the first citation merely because it appeared
@@ -3022,7 +3226,7 @@ Return exactly:
             elif len(valid) == 1:
                 selected_tag = valid[0]
                 coverage, overlap = self._citation_support_score(sentence, selected_tag)
-                if overlap >= 2 and coverage >= 0.12:
+                if retain_lexical and overlap >= 2 and coverage >= 0.12:
                     self._append_citation_audit(
                         section_name,
                         'retain_lexically_supported_source',
@@ -3048,7 +3252,7 @@ Return exactly:
                     reverse=True,
                 )
                 coverage, overlap, _, selected_tag = scored[0]
-                if overlap >= 2 and coverage >= 0.12:
+                if retain_lexical and overlap >= 2 and coverage >= 0.12:
                     revised = re.sub(
                         r'\s*[\[(]?CITE-\d+(?:\s*[,;]\s*CITE-\d+)*[\])]?\s*',
                         ' ',
@@ -3187,7 +3391,7 @@ Return exactly:
                     error.code,
                     error.safe_detail,
                 )
-                value = self._local_citation_recovery(value, section_name)
+                value = self._local_citation_recovery(value, section_name, retain_lexical=False)
             except Exception as error:
                 if bool(self.citation_semantic_audit.get('fail_closed', False)):
                     raise
@@ -3196,7 +3400,7 @@ Return exactly:
                     section_name,
                     self._safe_source_error(error),
                 )
-                value = self._local_citation_recovery(value, section_name)
+                value = self._local_citation_recovery(value, section_name, retain_lexical=False)
         elif violations:
             value = self._local_citation_recovery(value, section_name)
         if self.find_multi_citation_violations(value):

smartpaper_restore_bridge/frontend/index.html

@@ -408,6 +408,13 @@
     "әдебиеттер","пайдаланылған әдебиеттер"
   ]);
 
+  const UNNUMBERED_HEADING_PREFIXES = ["appendix", "附录", "приложение", "қосымша"];
+
+  function isUnnumberedHeading(value) {
+    const key = String(value || "").trim().toLocaleLowerCase();
+    return UNNUMBERED_HEADINGS.has(key) || UNNUMBERED_HEADING_PREFIXES.some(prefix => key.startsWith(prefix));
+  }
+
   function cleanHeadingTitle(value) {
     return String(value || "").trim().replace(/^\d+(?:\.\d+){0,2}\s+/, "");
   }
@@ -420,11 +427,11 @@
       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 hasFrontMatter = headingRows.some(row => isUnnumberedHeading(row.title));
     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 isKnownUnnumbered = isUnnumberedHeading(row.title);
       const isTitle = hasFrontMatter && firstH1 && row.index === firstH1.index && !isKnownUnnumbered;
       if (isKnownUnnumbered || isTitle) {
         lines[row.index] = row.title;

utils/docx_builder.py

@@ -3,7 +3,11 @@ import io
 import mistune
 from bs4 import BeautifulSoup
 from docx import Document
-from docx.shared import Pt
+from docx.shared import Pt, Inches
+from docx.enum.section import WD_SECTION, WD_ORIENT
+from docx.enum.table import WD_CELL_VERTICAL_ALIGNMENT
+from docx.oxml import OxmlElement
+from docx.oxml.ns import qn
 from config import APP_CONFIG
 
 
@@ -123,24 +127,75 @@ class DocxRenderer(mistune.HTMLRenderer):
     def table(self, text):
         soup = BeautifulSoup(text, 'html.parser')
         rows = soup.find_all('tr')
-        if not rows: 
+        if not rows:
             return ''
-            
+
         max_cols = max(len(row.find_all(['td', 'th'])) for row in rows)
-        if max_cols == 0: 
+        if max_cols == 0:
             return ''
-            
+
+        header_labels = [cell.get_text(strip=True) for cell in rows[0].find_all(['td', 'th'])]
+        qualitative_headers = [
+            'Higher-order Theme', 'Empirical Concept', 'Process Stage',
+            'Case/Actor', 'Evidence Role', 'Representative Quote',
+        ]
+        qualitative_evidence_table = header_labels == qualitative_headers
+
+        if qualitative_evidence_table:
+            previous = self.doc.sections[-1]
+            landscape = self.doc.add_section(WD_SECTION.NEW_PAGE)
+            landscape.orientation = WD_ORIENT.LANDSCAPE
+            landscape.page_width, landscape.page_height = previous.page_height, previous.page_width
+
         table = self.doc.add_table(rows=len(rows), cols=max_cols)
-        try: 
+        try:
             table.style = 'Table Grid'
-        except: 
+        except:
             pass
-            
+
+        if qualitative_evidence_table:
+            table.autofit = False
+        widths = [1.15, 1.10, 0.85, 0.85, 0.75, 3.80] if qualitative_evidence_table else []
+        if qualitative_evidence_table:
+            for grid_col, width in zip(table._tbl.tblGrid.gridCol_lst, widths):
+                grid_col.set(qn('w:w'), str(int(width * 1440)))
+
         for i, row in enumerate(rows):
             for j, cell in enumerate(row.find_all(['td', 'th'])):
-                if j < max_cols: 
-                    table.cell(i, j).text = cell.get_text(strip=True)
+                if j >= max_cols:
+                    continue
+                target = table.cell(i, j)
+                target.text = cell.get_text(strip=True)
+                if qualitative_evidence_table:
+                    target.vertical_alignment = WD_CELL_VERTICAL_ALIGNMENT.TOP
+                    target.width = Inches(widths[j])
+                    tc_pr = target._tc.get_or_add_tcPr()
+                    tc_w = tc_pr.first_child_found_in('w:tcW')
+                    if tc_w is not None:
+                        tc_w.set(qn('w:type'), 'dxa')
+                        tc_w.set(qn('w:w'), str(int(widths[j] * 1440)))
+                    for paragraph in target.paragraphs:
+                        paragraph.paragraph_format.space_before = Pt(0)
+                        paragraph.paragraph_format.space_after = Pt(0)
+                        for run in paragraph.runs:
+                            run.font.size = Pt(9)
+
+        if qualitative_evidence_table and table.rows:
+            header_pr = table.rows[0]._tr.get_or_add_trPr()
+            header = OxmlElement('w:tblHeader')
+            header.set(qn('w:val'), 'true')
+            header_pr.append(header)
+            for row in table.rows:
+                tr_pr = row._tr.get_or_add_trPr()
+                cant_split = OxmlElement('w:cantSplit')
+                tr_pr.append(cant_split)
+
         self.doc.add_paragraph()
+        if qualitative_evidence_table:
+            current = self.doc.sections[-1]
+            portrait = self.doc.add_section(WD_SECTION.NEW_PAGE)
+            portrait.orientation = WD_ORIENT.PORTRAIT
+            portrait.page_width, portrait.page_height = current.page_height, current.page_width
         return ''
 
     def thematic_break(self):