adeu 3.2.1__tar.gz → 3.2.2__tar.gz

{adeu-3.2.1 → adeu-3.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: adeu
-Version: 3.2.1
+Version: 3.2.2
 Summary: Automated DOCX Redlining Engine
 Project-URL: Homepage, https://adeu.ai
 Project-URL: Repository, https://github.com/dealfluence/adeu

{adeu-3.2.1 → adeu-3.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "adeu"
-version = "3.2.1"
+version = "3.2.2"
 description = "Automated DOCX Redlining Engine"
 authors = [
     { name = "Mikko Korpela" },

{adeu-3.2.1 → adeu-3.2.2}/server.json

@@ -6,12 +6,12 @@
     "url": "https://github.com/dealfluence/adeu",
     "source": "github"
   },
-  "version": "3.2.1",
+  "version": "3.2.2",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "@adeu/mcp-server",
-      "version": "3.2.1",
+      "version": "3.2.2",
       "transport": {
         "type": "stdio"
       }

{adeu-3.2.1 → adeu-3.2.2}/src/adeu/cli.py

@@ -830,7 +830,13 @@ def handle_extract(args):
         # modes it must be a positive integer; anything else is a hard error,
         # never a silent fallback to page 1 (QA L1).
         page_num = 1
-        want_all_pages = False
+        # Writing to a file (`-o <path>`, where `-o -` was already normalized to
+        # None above) defaults to the full document when `--page` is omitted:
+        # synthetic pagination protects stdout/LLM context windows, whereas file
+        # extraction is expected to contain the whole document.
+        want_all_pages = bool(
+            args.page is None and args.output and args.mode == "full" and not getattr(args, "search_query", None)
+        )
         is_page_range = False
         range_start = 1
         range_end = 1
@@ -1064,7 +1070,29 @@ def handle_extract(args):
         # extracted text otherwise. stdout stays quiet either way — printing
         # the full payload again surprised pipeline users (QA 2026-07-18 L4).
         _write_output_or_exit(args.output, json_output if json_output is not None else output_text)
-        print(f"Extracted {'JSON' if json_output is not None else 'text'} to {args.output}", file=sys.stderr)
+        status_msg = f"Extracted {'JSON' if json_output is not None else 'text'} to {args.output}"
+        if not getattr(args, "search_query", None) and args.mode == "full" and not want_all_pages:
+            from adeu.pagination import PAGE_RANGE_MAX_PAGES, paginate, split_structural_appendix
+
+            total_pages = paginate(split_structural_appendix(text)[0], "").total_pages
+            if is_page_range:
+                shown_end = min(range_end, range_start + PAGE_RANGE_MAX_PAGES - 1, total_pages)
+                if range_start > 1 or shown_end < total_pages:
+                    status_msg = (
+                        f"Extracted pages {range_start}-{shown_end} of {total_pages} to {args.output} "
+                        "(partial extract; pass --page all for the full document)"
+                    )
+            elif total_pages > 1:
+                status_msg = (
+                    f"Extracted page {page_num} of {total_pages} to {args.output} "
+                    "(partial extract; pass --page all for the full document)"
+                )
+        elif args.mode == "appendix" and "Continues on appendix page " in output_text:
+            status_msg = (
+                f"Extracted appendix page {page_num} to {args.output} "
+                "(partial appendix extract; pass --page N for subsequent pages)"
+            )
+        print(status_msg, file=sys.stderr)
     elif json_output is not None:
         print(json_output)
     else:
@@ -1203,11 +1231,19 @@ def handle_diff(args):
         try:
             doc_orig = _load_docx_or_exit(args.original)
             text_orig, struct_orig = _extract_text_from_doc(
-                doc_orig, clean_view=compare_clean, include_appendix=False, return_structure=True
+                doc_orig,
+                clean_view=compare_clean,
+                include_appendix=False,
+                return_structure=True,
+                resolve_numbering=False,
             )
             doc_mod = _load_docx_or_exit(args.modified)
             text_mod, struct_mod = _extract_text_from_doc(
-                doc_mod, clean_view=compare_clean, include_appendix=False, return_structure=True
+                doc_mod,
+                clean_view=compare_clean,
+                include_appendix=False,
+                return_structure=True,
+                resolve_numbering=False,
             )
         except SystemExit:
             raise
@@ -2114,7 +2150,12 @@ def _main_impl():
         action="store_true",
         help=f"{live_help_prefix}Extract text from live active Word document",
     )
-    p_extract.add_argument("-o", "--output", type=Path, help="Output file ('-' or omitted: stdout)")
+    p_extract.add_argument(
+        "-o",
+        "--output",
+        type=Path,
+        help="Output file ('-' or omitted: stdout; defaults --page to 'all' in full mode when omitted)",
+    )
     p_extract.add_argument(
         "--force",
         action="store_true",
@@ -2159,11 +2200,10 @@ def _main_impl():
         type=str,
         default=None,
         help=(
-            "Page number (1-indexed) for 'full' and 'appendix' modes (defaults to 1), "
-            "or 'all' to emit the entire document in one output (mode 'full' and search). "
-            "Use '--page all' when producing a text file for `adeu apply`/`adeu diff` — "
-            "a single page of a multi-page document cannot round-trip. Note: pages are "
-            "synthetic, length-based content chunks sized for LLM consumption — they do "
+            "Page number (1-indexed) for 'full' and 'appendix' modes (defaults to 1 on stdout and 'all' "
+            "when writing to -o <file>), or 'all' to emit the entire document in one output (mode 'full' "
+            "and search). A single page of a multi-page document cannot round-trip into `adeu apply`/`adeu diff`. "
+            "Note: pages are synthetic, length-based content chunks sized for LLM consumption — they do "
             "NOT correspond to printed Word pages or explicit page breaks."
         ),
     )

{adeu-3.2.1 → adeu-3.2.2}/src/adeu/compare.py

@@ -72,9 +72,11 @@ def refuse_input_alias(output_path: PathLike, original_path: PathLike, modified_
             )
 
 
-def apply_comparison_edits(original: bytes, edits: Sequence[DiffEdit], author: str) -> "tuple[bytes, int]":
+def apply_comparison_edits(
+    original: bytes, edits: Sequence[DiffEdit], author: str, resolve_numbering: bool = False
+) -> "tuple[bytes, int]":
     """Applies diff-generated edits to `original` as tracked changes; all of them or none."""
-    engine = RedlineEngine(BytesIO(original), author=author)
+    engine = RedlineEngine(BytesIO(original), author=author, resolve_numbering=resolve_numbering)
     applied, skipped = engine.apply_edits(list(edits))  # type: ignore[arg-type]
     if skipped:
         raise ComparisonError(
@@ -96,10 +98,18 @@ def build_redline_comparison(
     """Diffs two DOCX packages part by part and writes the result as a redline of `original`."""
     # Appendix excluded: its generated text is not writable content (QA 2026-07-18 H1).
     text_o, struct_o = _extract_text_from_doc(
-        Document(BytesIO(original)), clean_view=compare_clean, include_appendix=False, return_structure=True
+        Document(BytesIO(original)),
+        clean_view=compare_clean,
+        include_appendix=False,
+        return_structure=True,
+        resolve_numbering=False,
     )
     text_m, struct_m = _extract_text_from_doc(
-        Document(BytesIO(modified)), clean_view=compare_clean, include_appendix=False, return_structure=True
+        Document(BytesIO(modified)),
+        clean_view=compare_clean,
+        include_appendix=False,
+        return_structure=True,
+        resolve_numbering=False,
     )
     edits, warnings = generate_structured_edits(text_o, struct_o, text_m, struct_m)  # type: ignore[arg-type]
     warnings = list(warnings) + collect_media_difference_warnings(original, modified)

{adeu-3.2.1 → adeu-3.2.2}/src/adeu/disk_cache.py

@@ -9,6 +9,9 @@ from typing import Any, Dict, List, Optional, Tuple, Union
 from adeu import __version__
 from adeu.outline import OutlineNode
 
+# Increment whenever Virtual Text projection rules change without a package version bump.
+_CACHE_SCHEMA_VERSION = 2
+
 
 def get_default_cache_dir() -> Path:
     if env_dir := os.environ.get("ADEU_CACHE_DIR"):
@@ -125,6 +128,7 @@ class DiskProjectionCache:
                 or key.get("mtime_ns") != mtime_ns
                 or key.get("size") != size
                 or key.get("version") != __version__
+                or key.get("schema") != _CACHE_SCHEMA_VERSION
             ):
                 self._misses += 1
                 return None
@@ -165,6 +169,7 @@ class DiskProjectionCache:
                 "mtime_ns": mtime_ns,
                 "size": size,
                 "version": __version__,
+                "schema": _CACHE_SCHEMA_VERSION,
             }
 
             data: Dict[str, Any] = {"key": key_dict, "views": {}}

{adeu-3.2.1 → adeu-3.2.2}/src/adeu/ingest.py

@@ -25,6 +25,7 @@ from adeu.utils.content_controls import (
 )
 from adeu.utils.docx import (
     DocxEvent,
+    NumberingTracker,
     ProjectedRun,
     _get_style_cache,
     apply_formatting_to_segments,
@@ -95,6 +96,7 @@ def extract_text_from_stream(
     filename: str = "document.docx",
     clean_view: bool = False,
     include_appendix: bool = True,
+    resolve_numbering: bool = True,
 ) -> str:
     """
     Extracts text from a file stream using raw run concatenation.
@@ -106,6 +108,9 @@ def extract_text_from_stream(
         include_appendix: If False, omits the generated read-only structural
                     appendix — required whenever the text feeds a comparison
                     (QA 2026-07-18 H1).
+        resolve_numbering: If True (default), emits resolved OOXML clause/list
+                    numbers; if False, emits canonical '1. ' markers for
+                    DOCX-to-DOCX comparison.
 
     CRITICAL: This must match DocumentMapper._build_map logic exactly.
     """
@@ -114,7 +119,12 @@ def extract_text_from_stream(
 
         sanitized_bytes = strip_bom_from_docx_bytes(file_stream.read())
         doc = Document(io.BytesIO(sanitized_bytes))
-        return _extract_text_from_doc(doc, clean_view, include_appendix=include_appendix)
+        return _extract_text_from_doc(
+            doc,
+            clean_view,
+            include_appendix=include_appendix,
+            resolve_numbering=resolve_numbering,
+        )
     except Exception as e:
         logger.error(f"Text extraction failed: {e}", exc_info=True)
         raise ValueError(f"Could not extract text: {str(e)}") from e
@@ -126,6 +136,7 @@ def _extract_text_from_doc(
     include_appendix: bool = True,
     return_paragraph_offsets: bool = False,
     return_structure: bool = False,
+    resolve_numbering: bool = True,
 ):
     """
     Extracts text from an already-loaded python-docx Document.
@@ -177,6 +188,11 @@ def _extract_text_from_doc(
         # part_cursor accounts for the \n\n separator that will precede this part
         # in the final join, ensuring internal offsets align exactly.
         part_cursor = cursor + 2 if full_text else cursor
+        part_ref = getattr(part, "part", part)
+        part_style_cache, part_default_pstyle = _get_style_cache(part_ref)
+        numbering_tracker = NumberingTracker(
+            part_ref, style_cache=part_style_cache, resolve_numbering=resolve_numbering
+        )
         part_text = _extract_blocks(
             part,
             comments_map,
@@ -184,7 +200,12 @@ def _extract_text_from_doc(
             offset_map=offset_map,
             cursor=part_cursor,
             table_acc=structure.tables if structure is not None else None,
+            style_cache=part_style_cache,
+            default_pstyle=part_default_pstyle,
+            part=part_ref,
             sdt_infos=sdt_infos,
+            numbering_tracker=numbering_tracker,
+            resolve_numbering=resolve_numbering,
         )
         if part_text:
             if full_text:
@@ -223,6 +244,8 @@ def _extract_blocks(
     part: Any = None,
     sdt_infos: dict | None = None,
     in_cell: bool = False,
+    numbering_tracker: NumberingTracker | None = None,
+    resolve_numbering: bool = True,
 ) -> str:
     """
     Recursively extracts text from a container (Document, Cell, Header, etc.)
@@ -236,6 +259,8 @@ def _extract_blocks(
         part = getattr(container, "part", container)
     if style_cache is None:
         style_cache, default_pstyle = _get_style_cache(part)
+    if numbering_tracker is None:
+        numbering_tracker = NumberingTracker(part, style_cache=style_cache, resolve_numbering=resolve_numbering)
 
     blocks = []
     local_cursor = cursor
@@ -290,6 +315,8 @@ def _extract_blocks(
                 default_pstyle=default_pstyle,
                 part=part,
                 in_cell=in_cell,
+                numbering_tracker=numbering_tracker,
+                resolve_numbering=resolve_numbering,
             )
             if inner:
                 full = f"{open_tok}{inner}{close_tok}"
@@ -312,6 +339,9 @@ def _extract_blocks(
                 sdt_infos=sdt_infos,
                 style_cache=style_cache,
                 default_pstyle=default_pstyle,
+                part=part,
+                numbering_tracker=numbering_tracker,
+                resolve_numbering=resolve_numbering,
             )
             if fn_text:
                 blocks.append(fn_text)
@@ -324,7 +354,15 @@ def _extract_blocks(
                     local_cursor -= 2
         elif isinstance(item, Paragraph):
             p_elem = item._element
-            style_prefix = get_paragraph_prefix(p_elem, style_cache, default_pstyle, part=part)
+            num_snap = numbering_tracker.snapshot()
+            style_prefix = get_paragraph_prefix(
+                p_elem,
+                style_cache,
+                default_pstyle,
+                part=part,
+                numbering_tracker=numbering_tracker,
+                resolve_numbering=resolve_numbering,
+            )
             prefix = style_prefix
             if is_first_para and c_type == "FootnoteItem":
                 prefix = f"[^{container.note_type}-{container.id}]: " + prefix
@@ -345,6 +383,7 @@ def _extract_blocks(
                 # paragraph away; when nothing visible survives inside it,
                 # the accepted view must not render an empty container
                 # (QA round 3, finding 2.4).
+                numbering_tracker.restore(num_snap)
                 if not is_first_block:
                     local_cursor -= 2
                 is_first_para = False
@@ -375,6 +414,8 @@ def _extract_blocks(
                 style_cache=style_cache,
                 default_pstyle=default_pstyle,
                 part=part,
+                numbering_tracker=numbering_tracker,
+                resolve_numbering=resolve_numbering,
             )
             if table_text:
                 blocks.append(table_text)
@@ -402,6 +443,8 @@ def extract_table(
     default_pstyle: str | None = None,
     part: Any = None,
     sdt_infos: dict | None = None,
+    numbering_tracker: NumberingTracker | None = None,
+    resolve_numbering: bool = True,
 ) -> str:
     """
     Args:
@@ -463,6 +506,8 @@ def extract_table(
                 default_pstyle=default_pstyle,
                 part=part,
                 in_cell=True,
+                numbering_tracker=numbering_tracker,
+                resolve_numbering=resolve_numbering,
             )
             if cell_info is not None:
                 # Cell-level control (sdtContent > w:tc): anchors render inline

adeu-3.2.2/src/adeu/mcp_components/build_info.json

@@ -0,0 +1 @@
+{"git_sha": "03500b9", "build_timestamp": "20261111103826"}

{adeu-3.2.1 → adeu-3.2.2}/src/adeu/mcp_components/tools/document.py

@@ -1004,10 +1004,18 @@ async def diff_docx_files(
         # diagnostics) is not document content — diffing it produces phantom
         # changes no apply can consume (QA 2026-07-18 H1).
         text_orig = extract_text_from_stream(
-            stream_orig, filename=Path(original_path).name, clean_view=compare_clean, include_appendix=False
+            stream_orig,
+            filename=Path(original_path).name,
+            clean_view=compare_clean,
+            include_appendix=False,
+            resolve_numbering=False,
         )
         text_mod = extract_text_from_stream(
-            stream_mod, filename=Path(modified_path).name, clean_view=compare_clean, include_appendix=False
+            stream_mod,
+            filename=Path(modified_path).name,
+            clean_view=compare_clean,
+            include_appendix=False,
+            resolve_numbering=False,
         )
         # atomic_criticmarkup: diff-display only — hunks must never cut into a
         # {--/{++/{>>/{== block (QA 2026-07-23 F15). No-op on clean text.

{adeu-3.2.1 → adeu-3.2.2}/src/adeu/outline.py

@@ -16,6 +16,8 @@ from adeu.utils.docx import (
     QN_W_FOOTNOTEREFERENCE,
     QN_W_P,
     DocxEvent,
+    NumberingTracker,
+    _get_style_cache,
     get_paragraph_prefix,
     iter_block_items,
     iter_document_parts,
@@ -50,6 +52,7 @@ class _BlockRecord:
     is_table: bool
     start_offset: int  # offset in projected body where this block starts
     projected_length: int  # length of the projected text for this block
+    prefix: str = ""
 
 
 # ---------------------------------------------------------------------------
@@ -145,7 +148,7 @@ def extract_outline(
         paragraph = rec.item
 
         level = _heading_level(paragraph)
-        text = _heading_text(paragraph, comments_map)
+        text = _heading_text(paragraph, comments_map, prefix=rec.prefix)
         style = _determine_heading_style(paragraph)
 
         # Owned range: blocks strictly between this heading and the next equal-or-
@@ -476,10 +479,19 @@ def _walk_doc_body(doc: DocumentObject, comments_map: dict) -> List[_BlockRecord
     records: List[_BlockRecord] = []
     cursor = body_start_offset
     is_first_block = True
+    body_part_ref = getattr(body_part, "part", body_part)
+    body_style_cache, body_default_pstyle = _get_style_cache(body_part_ref)
+    body_tracker = NumberingTracker(body_part_ref, style_cache=body_style_cache)
 
     for item in iter_block_items(body_part):
         if isinstance(item, Paragraph):
-            prefix = get_paragraph_prefix(item)
+            prefix = get_paragraph_prefix(
+                item,
+                style_cache=body_style_cache,
+                default_pstyle=body_default_pstyle,
+                part=body_part_ref,
+                numbering_tracker=body_tracker,
+            )
             p_text = build_paragraph_text(item, comments_map, clean_view=False)
             block_len = len(prefix + p_text)
 
@@ -493,13 +505,15 @@ def _walk_doc_body(doc: DocumentObject, comments_map: dict) -> List[_BlockRecord
                     is_table=False,
                     start_offset=cursor,
                     projected_length=block_len,
+                    prefix=prefix,
                 )
             )
             cursor += block_len
             is_first_block = False
 
         elif isinstance(item, Table):
-            table_text = extract_table(item, comments_map, clean_view=False)
+            snap = body_tracker.snapshot()
+            table_text = extract_table(item, comments_map, clean_view=False, numbering_tracker=body_tracker)
             block_len = len(table_text) if table_text else 0
 
             if not is_first_block:
@@ -515,9 +529,12 @@ def _walk_doc_body(doc: DocumentObject, comments_map: dict) -> List[_BlockRecord
                     projected_length=block_len,
                 )
             )
-            # Record inner blocks for heading detection — but DO NOT call
-            # build_paragraph_text on them (we don't need their lengths).
-            _record_table_inner_blocks_lite(item, table_start, records, comments_map)
+            # Record inner blocks for heading detection — rewind a copy of
+            # body_tracker so inner heading prefixes match extract_table's pass.
+            after_table = body_tracker.snapshot()
+            body_tracker.restore(snap)
+            _record_table_inner_blocks_lite(item, table_start, records, comments_map, body_tracker)
+            body_tracker.restore(after_table)
             cursor += block_len
             is_first_block = False
 
@@ -678,17 +695,12 @@ def _record_table_inner_blocks_lite(
     inherited_offset: int,
     records: List[_BlockRecord],
     comments_map: dict,
+    numbering_tracker: Optional[NumberingTracker] = None,
 ) -> None:
     """
     PERF-optimized version of _record_table_inner_blocks: records inner
     paragraphs/tables for heading detection without paying the full projection
     cost for non-headings.
-
-    Headings inside tables get TRUE offsets computed via _compute_inner_block_offset
-    (so outline.page resolves correctly when a table spans page boundaries).
-    Non-heading inner blocks keep projected_length=0 and inherit the table's
-    start_offset — they are never used to resolve a page, only to scan for
-    nested headings/tables.
     """
     seen_cells: set = set()
     for row in iter_table_rows(table):
@@ -700,10 +712,14 @@ def _record_table_inner_blocks_lite(
 
             for inner_item in iter_block_items(cell):
                 if isinstance(inner_item, Paragraph):
-                    # Only pay the projection cost when the inner paragraph is
-                    # actually a heading — non-heading inner paragraphs do not
-                    # need a true offset (they're never assigned a page).
+                    prefix = (
+                        get_paragraph_prefix(inner_item, numbering_tracker=numbering_tracker)
+                        if numbering_tracker is not None
+                        else ""
+                    )
                     if _is_heading(inner_item):
+                        if not prefix:
+                            prefix = get_paragraph_prefix(inner_item)
                         true_offset = _compute_inner_block_offset(table, inner_item, inherited_offset, comments_map)
                     else:
                         true_offset = inherited_offset
@@ -715,6 +731,7 @@ def _record_table_inner_blocks_lite(
                             is_table=False,
                             start_offset=true_offset,
                             projected_length=0,
+                            prefix=prefix,
                         )
                     )
                 elif isinstance(inner_item, Table):
@@ -727,20 +744,22 @@ def _record_table_inner_blocks_lite(
                             projected_length=0,
                         )
                     )
-                    _record_table_inner_blocks_lite(inner_item, inherited_offset, records, comments_map)
+                    _record_table_inner_blocks_lite(
+                        inner_item, inherited_offset, records, comments_map, numbering_tracker
+                    )
 
 
-def _project_part(part, comments_map: dict) -> str:
+def _project_part(part, comments_map: dict, numbering_tracker: Optional[NumberingTracker] = None) -> str:
     """
     Renders a non-body document part (header/footer/notes) to measure its
-    projected length. Mirrors ingest._extract_blocks but inlined here so we
-    don't reach into ingest's private helpers.
-
-    Headers and footers iterate as Paragraphs/Tables. NotesPart is iterated
-    via FootnoteItem children.
+    projected length. Mirrors ingest._extract_blocks.
     """
     blocks: List[str] = []
     c_type = type(part).__name__
+    part_ref = getattr(part, "part", part)
+    if numbering_tracker is None:
+        style_cache, _ = _get_style_cache(part_ref)
+        numbering_tracker = NumberingTracker(part_ref, style_cache=style_cache)
 
     if c_type == "NotesPart":
         header = "## Footnotes" if part.note_type == "fn" else "## Endnotes"
@@ -751,18 +770,18 @@ def _project_part(part, comments_map: dict) -> str:
         i_type = type(item).__name__
 
         if i_type == "FootnoteItem":
-            fn_text = _project_part(item, comments_map)
+            fn_text = _project_part(item, comments_map, numbering_tracker=numbering_tracker)
             if fn_text:
                 blocks.append(fn_text)
         elif isinstance(item, Paragraph):
-            prefix = get_paragraph_prefix(item)
+            prefix = get_paragraph_prefix(item, part=part_ref, numbering_tracker=numbering_tracker)
             if is_first_para and c_type == "FootnoteItem":
                 prefix = f"[^{part.note_type}-{part.id}]: " + prefix
             p_text = build_paragraph_text(item, comments_map, clean_view=False)
             blocks.append(prefix + p_text)
             is_first_para = False
         elif isinstance(item, Table):
-            table_text = extract_table(item, comments_map, clean_view=False)
+            table_text = extract_table(item, comments_map, clean_view=False, numbering_tracker=numbering_tracker)
             if table_text:
                 blocks.append(table_text)
             is_first_para = False
@@ -907,12 +926,12 @@ def _heading_level(paragraph: Paragraph) -> int:
 # ---------------------------------------------------------------------------
 
 
-def _heading_text(paragraph: Paragraph, comments_map: dict) -> str:
+def _heading_text(paragraph: Paragraph, comments_map: dict, prefix: str = "") -> str:
     """
     Returns the heading text as the user would see it:
       - same projection as build_paragraph_text (so tracked changes / formatting
         look the same as in the body)
-      - heading prefix removed
+      - heading '#' prefix removed (while preserving any resolved heading clause number)
       - CriticMarkup tags stripped (insertions kept as plain text, deletions
         and meta-blocks dropped)
       - internal newlines collapsed to a single space BEFORE marker stripping —
@@ -927,7 +946,8 @@ def _heading_text(paragraph: Paragraph, comments_map: dict) -> str:
         (QA 2026-07-23 F13b).
     """
     p_text = build_paragraph_text(paragraph, comments_map, clean_view=False)
-    cleaned = _strip_critic_markup(p_text)
+    heading_num_label = re.sub(r"^#+\s+", "", prefix) if prefix else ""
+    cleaned = _strip_critic_markup(heading_num_label + p_text)
     cleaned = re.sub(r"\s*\n\s*", " ", cleaned)
     cleaned = _strip_inline_formatting(cleaned)
     return _truncate_outline_text(cleaned.strip())