Fix body page count: use LaTeX \pdfsavepos instead of PDF text-block analysis

The old PyMuPDF-based method counted page numbers and footers as body content,
inflating the fill ratio (e.g. 8.95 instead of 8.25) and letting nearly-empty
last pages pass the page count check. Now injects \pdfsavepos before
\clearpage\bibliography to write the exact body-end y-coordinate to .aux,
giving an accurate fill ratio immune to headers/footers/page numbers.
Falls back to the old PDF method when aux data is unavailable.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: JihaoXin

ark/compiler.py

@@ -277,14 +277,76 @@ def _count_pdf_pages(self, pdf_path: Path) -> int:
         return 0
 
     def _count_body_pages(self, pdf_path: Path) -> float:
-        """Count body pages (before References section) using PyMuPDF.
+        """Count body pages (before References section).
 
-        For dual-column templates, measures the RIGHT column fill on the last
-        body page, which is what matters for page limit compliance.
+        Primary method: read \\arkBodyEndY / \\arkPageH from the .aux file
+        (injected by _ensure_clearpage_before_bibliography via \\pdfsavepos).
+        This gives the exact y-position where body text ends, immune to
+        page-number / header / footer interference.
+
+        Fallback: PyMuPDF text-block analysis (less accurate).
 
         Returns a float: e.g. 5.8 means 5 full pages + last page 80% filled.
-        For dual-column: last page fill = right column fill ratio (not left).
         """
+        # ── Try aux-based measurement first ──
+        result = self._count_body_pages_from_aux(pdf_path)
+        if result is not None:
+            return result
+
+        # ── Fallback: PyMuPDF text-block analysis ──
+        return self._count_body_pages_from_pdf(pdf_path)
+
+    def _count_body_pages_from_aux(self, pdf_path: Path) -> float | None:
+        """Read body-end position from .aux file (written by \\pdfsavepos).
+
+        Returns body page count as a float, or None if aux data unavailable.
+        """
+        aux_path = self.latex_dir / "main.aux"
+        if not aux_path.exists():
+            return None
+        try:
+            aux_text = aux_path.read_text(errors="replace")
+            import re
+            m_y = re.search(r'\\gdef\\arkBodyEndY\{(\d+)\}', aux_text)
+            m_h = re.search(r'\\gdef\\arkPageH\{(\d+)\}', aux_text)
+            if not m_y or not m_h:
+                return None
+
+            body_end_y_sp = int(m_y.group(1))   # sp from page bottom
+            page_height_sp = int(m_h.group(1))   # total page height in sp
+            if page_height_sp <= 0:
+                return None
+
+            # fill_ratio = fraction of page used (from top)
+            fill_ratio = 1.0 - (body_end_y_sp / page_height_sp)
+
+            # Determine which page the body ends on by finding References page
+            import fitz
+            doc = fitz.open(str(pdf_path))
+            ref_page_idx = None
+            for i in range(len(doc)):
+                text = doc[i].get_text()
+                if any(line.strip() == 'References' for line in text.split('\n')):
+                    ref_page_idx = i
+                    break
+            doc.close()
+
+            if ref_page_idx is None:
+                return None  # can't determine without References marker
+
+            # Body ends on the page before References (since we inject
+            # the marker right before \clearpage\bibliography)
+            last_body_idx = max(ref_page_idx - 1, 0)
+            result = last_body_idx + fill_ratio
+            self.log(f"Body page count (aux): {result:.2f} "
+                     f"(page {last_body_idx+1}, {fill_ratio:.1%} filled)", "DEBUG")
+            return result
+        except Exception as e:
+            self.log(f"Aux-based page count failed: {e}", "DEBUG")
+            return None
+
+    def _count_body_pages_from_pdf(self, pdf_path: Path) -> float:
+        """Fallback: count body pages via PyMuPDF text-block analysis."""
         try:
             import fitz
             doc = fitz.open(str(pdf_path))
@@ -307,7 +369,6 @@ def _count_body_pages(self, pdf_path: Path) -> float:
             # (if References has its own page via \clearpage)
             # OR the same page (if References starts mid-page)
             ref_page = doc[ref_page_idx]
-            ref_page_text = ref_page.get_text()
 
             # Check if References is at the very top of its page (i.e., \clearpage was used)
             ref_y = 0
@@ -354,8 +415,6 @@ def _count_body_pages(self, pdf_path: Path) -> float:
                 fill_ratio = right_last_y / page_height
             elif ref_at_top:
                 # Single column, References on separate page: check last body page fill
-                # Filter out headers/footers: ignore blocks in top 8% and bottom 5% of page,
-                # and blocks shorter than 10 chars (page numbers, headers)
                 body_blocks = [
                     b for b in blocks
                     if b[3] > page_height * 0.06       # below header

ark/execution.py

@@ -724,29 +724,66 @@ def _enforce_page_count(self, context: str = "post-writing") -> bool:
                 self.log(f"[{context}] Could not determine page count after {action}", "WARN")
                 return True
 
+    # LaTeX snippet that saves the current vertical position to the .aux file.
+    # \pdfsavepos records the position at shipout; the deferred \write expands
+    # \pdflastypos at that moment, giving the y-coordinate (in sp, from the
+    # page bottom).  Must use \write (not \protected@write) so expansion
+    # happens at shipout time, after \pdfsavepos has recorded the position.
+    _ARK_BODY_END_MARKER = (
+        r"\makeatletter\pdfsavepos"
+        r"\write\@auxout{\string\gdef\string\arkBodyEndY{\the\pdflastypos}"
+        r"\string\gdef\string\arkPageH{\number\pdfpageheight}}"
+        r"\makeatother"
+    )
+
     def _ensure_clearpage_before_bibliography(self):
         """Ensure \\clearpage before \\bibliography in main.tex.
 
         This guarantees References starts on a new page, separate from body.
+        Also injects a \\pdfsavepos marker right before the first \\clearpage
+        so the exact body-end y-position is written to the .aux file.
         """
         main_tex = self.latex_dir / "main.tex"
         if not main_tex.exists():
             return
         try:
             content = main_tex.read_text()
-            marker = r'\bibliography{'
-            if marker not in content:
-                return
-            # Clean up any old FloatBarrier injections
-            content = content.replace('\\FloatBarrier\n\\clearpage\n' + marker, marker)
-            content = content.replace('\\FloatBarrier\n' + marker, marker)
-            # Check if \clearpage already precedes \bibliography
-            if '\\clearpage\n' + marker in content or '\\clearpage\n\n' + marker in content:
+            if r'\bibliography{' not in content:
                 return
-            # Insert \clearpage before \bibliography
-            content = content.replace(marker, '\\clearpage\n' + marker)
+
+            # Remove any previously injected body-end marker (idempotent)
+            content = content.replace(self._ARK_BODY_END_MARKER + '\n', '')
+
+            # Find the first bibliography-related command (\bibliographystyle or \bibliography)
+            bib_style_pos = content.find(r'\bibliographystyle{')
+            bib_pos = content.find(r'\bibliography{')
+            # The anchor is whichever comes first
+            anchor_pos = min(p for p in (bib_style_pos, bib_pos) if p >= 0)
+
+            # Check if \clearpage already precedes the anchor
+            before_anchor = content[:anchor_pos].rstrip()
+            has_clearpage = before_anchor.endswith(r'\clearpage')
+
+            if not has_clearpage:
+                # Insert \clearpage before the anchor
+                content = content[:anchor_pos] + '\\clearpage\n' + content[anchor_pos:]
+                self.log("Injected \\clearpage before \\bibliography", "INFO")
+                # Recalculate anchor position
+                anchor_pos = min(
+                    p for p in (content.find(r'\bibliographystyle{'),
+                                content.find(r'\bibliography{'))
+                    if p >= 0
+                )
+                before_anchor = content[:anchor_pos].rstrip()
+
+            # Inject pdfsavepos marker before the first \clearpage
+            # Find the \clearpage that immediately precedes the anchor
+            clearpage_pos = before_anchor.rfind(r'\clearpage')
+            content = (content[:clearpage_pos]
+                       + self._ARK_BODY_END_MARKER + '\n'
+                       + content[clearpage_pos:])
+
             main_tex.write_text(content)
-            self.log("Injected \\clearpage before \\bibliography", "INFO")
         except Exception as e:
             self.log(f"Failed to inject \\clearpage: {e}", "WARN")