@adeu/core 1.27.0 → 1.29.0

package/src/ingest.test.ts

@@ -23,7 +23,9 @@ describe('Ingestion Engine (Node.js Port)', () => {
     expect(markdown.length).toBeGreaterThan(0);
     
     // Assert exact parity with the Python engine's CriticMarkup generation
-    expect(markdown).toBe('This is the {--initial --}{++golden ++}{>>[Chg:3 delete] Mikko Korpela\n[Chg:4 insert] Mikko Korpela\n[Com:0] Mikko Korpela @ 2026-01-23T07:25:00Z: Start of comment thread\n[Com:1] Mikko Korpela @ 2026-01-23T07:25:00Z: Second comment\n[Com:2] Mikko Korpela @ 2026-01-23T07:26:00Z: Third comment in the thread<<}document');
+    // The del+ins pair of one modification is annotated as a resolution
+    // group (QA 2026-07-19 ADEU-QA-004).
+    expect(markdown).toBe('This is the {--initial --}{++golden ++}{>>[Chg:3 delete] Mikko Korpela (pairs with Chg:4)\n[Chg:4 insert] Mikko Korpela (pairs with Chg:3)\n[Com:0] Mikko Korpela @ 2026-01-23T07:25:00Z: Start of comment thread\n[Com:1] Mikko Korpela @ 2026-01-23T07:25:00Z: Second comment\n[Com:2] Mikko Korpela @ 2026-01-23T07:26:00Z: Third comment in the thread<<}document');
   });
 
   it('should execute in cleanView mode without failing', async () => {

package/src/ingest.ts

@@ -2,6 +2,7 @@ import { DocumentObject } from "./docx/bridge.js";
 import { Paragraph, Table, Run, DocxEvent } from "./docx/primitives.js";
 import {
   _get_style_cache,
+  compute_change_pair_map,
   get_paragraph_prefix,
   is_heading_paragraph,
   is_native_heading,
@@ -253,12 +254,30 @@ export function extract_table(
       // via the mapper). We key on the cell's first paragraph w14:paraId, which
       // Word assigns and keeps stable across reads.
       if (!cleanView) {
-        const firstP = cell._element.getElementsByTagName("w:p")[0] as
+        let firstP = cell._element.getElementsByTagName("w:p")[0] as
           | Element
           | undefined;
-        const paraId = firstP ? firstP.getAttribute("w14:paraId") : null;
+        let paraId = firstP ? firstP.getAttribute("w14:paraId") : null;
+        if (!paraId && (!cell_content || cell_content.trim() === "")) {
+          if (!firstP) {
+            const xmlDoc = cell._element.ownerDocument!;
+            firstP = xmlDoc.createElement("w:p");
+            cell._element.appendChild(firstP);
+          }
+          const allPs = Array.from(cell._element.ownerDocument!.getElementsByTagName("w:p"));
+          const index = allPs.indexOf(firstP);
+          let hash = 2166136261;
+          const str = `fallback-paraId-${index}`;
+          for (let i = 0; i < str.length; i++) {
+            hash ^= str.charCodeAt(i);
+            hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
+          }
+          paraId = (hash >>> 0).toString(16).toUpperCase().padStart(8, '0');
+          firstP.setAttribute("w14:paraId", paraId);
+        }
         if (paraId) {
-          const anchor = `{#cell:${paraId}}`;
+          const space_pad = cell_content ? " " : "";
+          const anchor = `${space_pad}{#cell:${paraId}}`;
           cell_content = cell_content + anchor;
         }
       }
@@ -603,13 +622,22 @@ function _build_merged_meta_block(
   const comment_lines: string[] = [];
   const seen_sigs = new Set<string>();
 
+  // Ids of one resolution group (a replacement's contiguous same-author
+  // del+ins pair) must not read as independently resolvable — either side
+  // resolves the whole group (QA 2026-07-19 ADEU-QA-004).
+  const pair_map = compute_change_pair_map(states_list);
+  const pairSuffix = (uid: string): string =>
+    pair_map[uid] ? ` (pairs with ${pair_map[uid]})` : "";
+
   for (const [ins_map, del_map, comments_set, fmt_map] of states_list) {
     for (const [uid, meta] of Object.entries(
       ins_map as Record<string, DocxEvent>,
     )) {
       const sig = `Chg:${uid}`;
       if (!seen_sigs.has(sig)) {
-        change_lines.push(`[${sig} insert] ${meta.author || "Unknown"}`);
+        change_lines.push(
+          `[${sig} insert] ${meta.author || "Unknown"}${pairSuffix(uid)}`,
+        );
         seen_sigs.add(sig);
       }
     }
@@ -618,7 +646,9 @@ function _build_merged_meta_block(
     )) {
       const sig = `Chg:${uid}`;
       if (!seen_sigs.has(sig)) {
-        change_lines.push(`[${sig} delete] ${meta.author || "Unknown"}`);
+        change_lines.push(
+          `[${sig} delete] ${meta.author || "Unknown"}${pairSuffix(uid)}`,
+        );
         seen_sigs.add(sig);
       }
     }

package/src/mapper.ts

@@ -5,6 +5,7 @@ import { extract_comments_data } from "./comments.js";
 import { RegexTimeoutError, userFindAllMatches, userSearch } from "./utils/safe-regex.js";
 import {
   _get_style_cache,
+  compute_change_pair_map,
   get_paragraph_prefix,
   get_run_style_markers,
   get_run_text,
@@ -347,16 +348,39 @@ export class DocumentMapper {
         // can resolve "write into this cell" even when the cell is empty
         // (pPr-only paragraph with no run).
         if (!this.clean_view && !this.original_view) {
-          const firstP = cell._element.getElementsByTagName("w:p")[0] as
+          let firstP = cell._element.getElementsByTagName("w:p")[0] as
             | Element
             | undefined;
-          const paraId = firstP ? firstP.getAttribute("w14:paraId") : null;
+          let paraId = firstP ? firstP.getAttribute("w14:paraId") : null;
+          const is_empty = current === cell_start;
+          if (!paraId && is_empty) {
+            if (!firstP) {
+              const xmlDoc = cell._element.ownerDocument!;
+              firstP = xmlDoc.createElement("w:p");
+              cell._element.appendChild(firstP);
+            }
+            const allPs = Array.from(cell._element.ownerDocument!.getElementsByTagName("w:p"));
+            const index = allPs.indexOf(firstP);
+            let hash = 2166136261;
+            const str = `fallback-paraId-${index}`;
+            for (let i = 0; i < str.length; i++) {
+              hash ^= str.charCodeAt(i);
+              hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
+            }
+            paraId = (hash >>> 0).toString(16).toUpperCase().padStart(8, '0');
+            firstP.setAttribute("w14:paraId", paraId);
+          }
           if (paraId && firstP) {
             // Zero-width span bound to the empty cell paragraph: gives
             // get_insertion_anchor a paragraph to land on. Placed at the anchor
             // token offset so resolution targets THIS cell, not a neighbour.
             const cellPara = new Paragraph(firstP, cell);
             this._add_virtual_text("", current, cellPara);
+            const has_content = current > cell_start;
+            if (has_content) {
+              this._add_virtual_text(" ", current, cellPara);
+              current += 1;
+            }
             const anchor = `{#cell:${paraId}}`;
             this._add_virtual_text(anchor, current, cellPara);
             current += anchor.length;
@@ -810,6 +834,13 @@ export class DocumentMapper {
     const comment_lines: string[] = [];
     const seen_sigs = new Set<string>();
 
+    // Must render EXACTLY as ingest's _build_merged_meta_block (Virtual Text
+    // contract), including the resolution-group annotation
+    // (QA 2026-07-19 ADEU-QA-004).
+    const pair_map = compute_change_pair_map(states_list);
+    const pairSuffix = (uid: string): string =>
+      pair_map[uid] ? ` (pairs with ${pair_map[uid]})` : "";
+
     for (const [ins_map, del_map, comments_set, fmt_map] of states_list) {
       for (const [uid, meta] of Object.entries(
         ins_map as Record<string, DocxEvent>,
@@ -817,7 +848,7 @@ export class DocumentMapper {
         const sig = `Chg:${uid}`;
         if (!seen_sigs.has(sig)) {
           const auth = meta.author || "Unknown";
-          change_lines.push(`[${sig} insert] ${auth}`);
+          change_lines.push(`[${sig} insert] ${auth}${pairSuffix(uid)}`);
           seen_sigs.add(sig);
         }
       }
@@ -827,7 +858,7 @@ export class DocumentMapper {
         const sig = `Chg:${uid}`;
         if (!seen_sigs.has(sig)) {
           const auth = meta.author || "Unknown";
-          change_lines.push(`[${sig} delete] ${auth}`);
+          change_lines.push(`[${sig} delete] ${auth}${pairSuffix(uid)}`);
           seen_sigs.add(sig);
         }
       }
@@ -1000,6 +1031,40 @@ export class DocumentMapper {
     return results;
   }
 
+  /**
+   * True when no run-backed span overlaps [start, start+length): the range
+   * covers only virtual projection text — meta bubbles (change/comment
+   * headers, timestamps), style markers, list prefixes. Such text does not
+   * exist in the document, so it can neither satisfy a match nor count
+   * toward ambiguity (QA 2026-07-19 ADEU-QA-002 C): an edit targeting "4"
+   * used to be rejected as "appears 8 times" because a comment bubble's
+   * timestamp matched.
+   *
+   * Anchor tokens ({#Bookmark}, {#cell:paraId}) are the exception: they are
+   * deliberate virtual TARGETING surfaces (empty-cell writes, bookmark
+   * anchors) and must stay matchable.
+   */
+  public range_is_virtual_only(start: number, length: number): boolean {
+    const end = start + length;
+    const overlapping = this.spans.filter(
+      (s) => s.end > start && s.start < end,
+    );
+    if (overlapping.some((s) => s.run !== null)) return false;
+    return !overlapping.some(
+      (s) => s.run === null && s.text.startsWith("{#"),
+    );
+  }
+
+  /** Filters find_all_match_indices output down to matches that touch at
+   * least one run-backed span. See range_is_virtual_only. */
+  public drop_virtual_only_matches(
+    matches: [number, number][],
+  ): [number, number][] {
+    return matches.filter(
+      ([start, length]) => !this.range_is_virtual_only(start, length),
+    );
+  }
+
   public find_match_index(
     target_text: string,
     is_regex: boolean = false,
@@ -1011,19 +1076,33 @@ export class DocumentMapper {
       // invalid-pattern errors mean "no match" here.
       try {
         const match = userSearch(target_text, this.full_text);
-        if (match) return [match.start, match.end - match.start];
+        if (
+          match &&
+          !this.range_is_virtual_only(match.start, match.end - match.start)
+        ) {
+          return [match.start, match.end - match.start];
+        }
       } catch (e) {
         if (e instanceof RegexTimeoutError) throw e;
       }
       return [-1, 0];
     }
 
-    let start_idx = this.full_text.indexOf(target_text);
-    if (start_idx !== -1) return [start_idx, target_text.length];
+    // Exact tier: skip occurrences that cover only virtual projection text
+    // (meta bubbles, markers) — they are not document text (ADEU-QA-002 C).
+    let from = 0;
+    while (true) {
+      const idx = this.full_text.indexOf(target_text, from);
+      if (idx === -1) break;
+      if (!this.range_is_virtual_only(idx, target_text.length)) {
+        return [idx, target_text.length];
+      }
+      from = idx + 1;
+    }
 
     const norm_full = this._replace_smart_quotes(this.full_text);
     const norm_target = this._replace_smart_quotes(target_text);
-    start_idx = norm_full.indexOf(norm_target);
+    let start_idx = norm_full.indexOf(norm_target);
     if (start_idx !== -1) return [start_idx, target_text.length];
 
     const stripped_target = this._strip_markdown_formatting(target_text);
@@ -1039,9 +1118,13 @@ export class DocumentMapper {
     if (plain_first.length > 0) return plain_first[0];
 
     try {
-      const pattern = new RegExp(this._make_fuzzy_regex(target_text));
-      const match = pattern.exec(this.full_text);
-      if (match) return [match.index, match[0].length];
+      const pattern = new RegExp(this._make_fuzzy_regex(target_text), "g");
+      for (const match of this.full_text.matchAll(pattern)) {
+        // Virtual-only ranges are projection chrome, not document text.
+        if (!this.range_is_virtual_only(match.index!, match[0].length)) {
+          return [match.index!, match[0].length];
+        }
+      }
     } catch (e) {}
 
     return [-1, 0];

package/src/repro_agy_bug.test.ts

@@ -0,0 +1,108 @@
+import { describe, it, expect } from "vitest";
+import { createTestDocument, addTable, setCellText } from "./test-utils.js";
+import { extractTextFromBuffer } from "./ingest.js";
+import { RedlineEngine } from "./engine.js";
+
+describe("QA Regression Test - Finding F1: Missing cell anchors for empty table cells", () => {
+  it("should generate and render stable cell anchors for empty table cells", async () => {
+    // 1. Build a document containing a table with empty/blank cells.
+    // In this document, the cells are constructed programmatically without any pre-existing w14:paraId.
+    const doc = await createTestDocument();
+    const tbl = addTable(doc, 1, 2);
+    setCellText(tbl, 0, 0, "Hello");
+    // Cell (0,1) is left completely empty, with no pre-existing w14:paraId attribute on its w:p element.
+
+    const buf = await doc.save();
+
+    // 2. Ingest/extract text from the document.
+    const text = await extractTextFromBuffer(buf, false);
+
+    // 3. Assert correct behavior.
+    // The empty cell must still render a trailing {#cell:<id>} anchor so that it can be targeted for edits.
+    // We expect the output to be formatted like: Hello | {#cell:<id>}
+    const cellAnchorRegex = /Hello \| \{#cell:[0-9a-fA-F]{8}\}/;
+    expect(text).toSatisfy((val: string) => {
+      return cellAnchorRegex.test(val);
+    }, `Expected extracted text to contain a cell anchor for the empty cell, but got:\n"${text}"`);
+  });
+});
+
+describe("QA Regression Test - Top Bug: match_mode='all' fails to affect multiple matches for table row edits", () => {
+  it("should delete all rows containing target_text when match_mode is all", async () => {
+    const doc = await createTestDocument();
+    const tbl = addTable(doc, 3, 3);
+    setCellText(tbl, 0, 0, "ID");
+    setCellText(tbl, 0, 1, "Name");
+    setCellText(tbl, 0, 2, "Notes");
+
+    setCellText(tbl, 1, 0, "1");
+    setCellText(tbl, 1, 1, "Alice");
+    setCellText(tbl, 1, 2, "First record");
+
+    setCellText(tbl, 2, 0, "2");
+    setCellText(tbl, 2, 1, "");
+    setCellText(tbl, 2, 2, "Second record with empty name");
+
+    const buf = await doc.save();
+    const midDoc = await (doc.constructor as any).load(buf);
+
+    const engine = new RedlineEngine(midDoc);
+    const stats = engine.process_batch([
+      {
+        type: "delete_row",
+        target_text: "record",
+        match_mode: "all",
+      } as any,
+    ]);
+
+    expect(stats.edits_applied).toBe(1);
+    expect(stats.occurrences_modified).toBe(2);
+
+    engine.accept_all_revisions();
+    const finalBuf = await midDoc.save();
+    const clean_text = await extractTextFromBuffer(finalBuf, true);
+
+    expect(clean_text).not.toContain("First record");
+    expect(clean_text).not.toContain("Second record with empty name");
+  });
+
+  it("should insert rows adjacent to all rows containing target_text when match_mode is all", async () => {
+    const doc = await createTestDocument();
+    const tbl = addTable(doc, 3, 3);
+    setCellText(tbl, 0, 0, "ID");
+    setCellText(tbl, 0, 1, "Name");
+    setCellText(tbl, 0, 2, "Notes");
+
+    setCellText(tbl, 1, 0, "1");
+    setCellText(tbl, 1, 1, "Alice");
+    setCellText(tbl, 1, 2, "First record");
+
+    setCellText(tbl, 2, 0, "2");
+    setCellText(tbl, 2, 1, "");
+    setCellText(tbl, 2, 2, "Second record with empty name");
+
+    const buf = await doc.save();
+    const midDoc = await (doc.constructor as any).load(buf);
+
+    const engine = new RedlineEngine(midDoc);
+    const stats = engine.process_batch([
+      {
+        type: "insert_row",
+        target_text: "record",
+        match_mode: "all",
+        position: "below",
+        cells: ["NEW_ID", "NEW_NAME", "NEW_NOTES"],
+      } as any,
+    ]);
+
+    expect(stats.edits_applied).toBe(1);
+    expect(stats.occurrences_modified).toBe(2);
+
+    engine.accept_all_revisions();
+    const finalBuf = await midDoc.save();
+    const clean_text = await extractTextFromBuffer(finalBuf, true);
+
+    const occurrences = (clean_text.match(/NEW_ID \| NEW_NAME \| NEW_NOTES/g) || []).length;
+    expect(occurrences).toBe(2);
+  });
+});

package/src/repro_qa_mcp_issues_2026_07_20.test.ts

@@ -0,0 +1,224 @@
+import { describe, it, expect } from "vitest";
+import { createTestDocument, addParagraph, addTable, setCellText } from "./test-utils.js";
+import { _extractTextFromDoc, extractTextFromBuffer } from "./ingest.js";
+import { RedlineEngine } from "./engine.js";
+import { extract_outline } from "./outline.js";
+import { paginate } from "./pagination.js";
+import { finalize_document } from "./sanitize/core.js";
+import { findChild, findAllDescendants, QN_W_R, QN_W_RPR, QN_W_B, QN_W_VAL, QN_W_T } from "./utils/docx.js";
+
+describe("Adeu MCP QA Report - Issue 1: Markdown headings in new_text", () => {
+  it("TC 1.1: single modify to ### heading changes style and is visible in outline", async () => {
+    const doc = await createTestDocument();
+    addParagraph(doc, "This is a normal paragraph.");
+
+    const engine = new RedlineEngine(doc);
+    const res = engine.process_batch([
+      {
+        type: "modify",
+        target_text: "This is a normal paragraph.",
+        new_text: "### Heading Only Test",
+      },
+    ]);
+
+    expect(res.edits_applied).toBe(1);
+
+    // Re-extract outline
+    const extract_res = _extractTextFromDoc(doc, false, false, true) as {
+      text: string;
+      paragraph_offsets: Map<any, [number, number]>;
+    };
+    const pages = paginate(extract_res.text, "");
+    const nodes = extract_outline(
+      doc,
+      extract_res.text,
+      pages.body_pages,
+      pages.body_page_offsets,
+      extract_res.paragraph_offsets as any,
+    );
+
+    // The heading must be present in the outline
+    const testNode = nodes.find((n) => n.text.includes("Heading Only Test"));
+    expect(testNode).toBeDefined();
+    expect(testNode!.level).toBe(3);
+  });
+
+  it("TC 1.2: multi-paragraph insert with heading does not leak ### prefix to other paragraphs", async () => {
+    const doc = await createTestDocument();
+    addParagraph(doc, "Replace me.");
+
+    const engine = new RedlineEngine(doc);
+    const res = engine.process_batch([
+      {
+        type: "modify",
+        target_text: "Replace me.",
+        new_text: "### Title\n\nBody with **bold** and _italic_.\n\nSecond paragraph.",
+      },
+    ]);
+
+    expect(res.edits_applied).toBe(1);
+
+    const buf = await doc.save();
+    const cleanText = await extractTextFromBuffer(buf, true);
+
+    // Subsequent paragraphs must not have literal "###" prepended
+    expect(cleanText).toContain("Body with **bold** and _italic_.");
+    expect(cleanText).toContain("Second paragraph.");
+    expect(cleanText).not.toContain("### Body with");
+    expect(cleanText).not.toContain("### Second");
+  });
+});
+
+describe("Adeu MCP QA Report - Issue 2: Bold/large-font table cells misclassified as headings", () => {
+  it("TC 2.1: bold table cell with uppercase/numeric text is NOT classified as a heading", async () => {
+    const doc = await createTestDocument();
+    const tbl = addTable(doc, 1, 1);
+    setCellText(tbl, 0, 0, "$ 88,136 $ 72,361 $ 72,738");
+
+    // Make the run inside the cell bold
+    const p = tbl.getElementsByTagName("w:p")[0];
+    const r = p.getElementsByTagName("w:r")[0];
+    const xmlDoc = doc.element.ownerDocument!;
+    const rPr = xmlDoc.createElement("w:rPr");
+    const b = xmlDoc.createElement("w:b");
+    rPr.appendChild(b);
+    r.insertBefore(rPr, r.firstChild);
+
+    // Re-extract outline
+    const extract_res = _extractTextFromDoc(doc, false, false, true) as {
+      text: string;
+      paragraph_offsets: Map<any, [number, number]>;
+    };
+    const pages = paginate(extract_res.text, "");
+    const nodes = extract_outline(
+      doc,
+      extract_res.text,
+      pages.body_pages,
+      pages.body_page_offsets,
+      extract_res.paragraph_offsets as any,
+    );
+
+    // The outline should be empty or should NOT contain the table cell text as a heading
+    const fakeHeading = nodes.find((n) => n.text.includes("$ 88,136"));
+    expect(fakeHeading).toBeUndefined();
+  });
+});
+
+describe("Adeu MCP QA Report - Issue 3: insert_row/delete_row with anchor-only target", () => {
+  it("TC 3.1: insert_row succeeds when targeted with a {#cell:paraId} anchor alone", async () => {
+    const doc = await createTestDocument();
+    const tbl = addTable(doc, 1, 2);
+    setCellText(tbl, 0, 0, "A1");
+    setCellText(tbl, 0, 1, "A2");
+
+    // Add w14:paraId to the paragraph of cell 0 to act as our stable anchor
+    const rows = Array.from(tbl.childNodes).filter((n) => (n as Element).tagName === "w:tr") as Element[];
+    const cells = Array.from(rows[0].childNodes).filter((n) => (n as Element).tagName === "w:tc") as Element[];
+    const p = cells[0].getElementsByTagName("w:p")[0];
+    p.setAttribute("w14:paraId", "DEADBEEF");
+
+    const engine = new RedlineEngine(doc);
+    const res = engine.process_batch([
+      {
+        type: "insert_row",
+        target_text: "{#cell:DEADBEEF}",
+        cells: ["B1", "B2"],
+        position: "below",
+      } as any,
+    ]);
+
+    expect(res.edits_applied).toBe(1);
+  });
+
+  it("TC 3.2: delete_row succeeds when targeted with a {#cell:paraId} anchor alone", async () => {
+    const doc = await createTestDocument();
+    const tbl = addTable(doc, 2, 2);
+    setCellText(tbl, 0, 0, "A1");
+    setCellText(tbl, 0, 1, "A2");
+    setCellText(tbl, 1, 0, "B1");
+    setCellText(tbl, 1, 1, "B2");
+
+    // Add w14:paraId to the paragraph of cell (0,0) to act as our stable anchor
+    const rows = Array.from(tbl.childNodes).filter((n) => (n as Element).tagName === "w:tr") as Element[];
+    const cells0 = Array.from(rows[0].childNodes).filter((n) => (n as Element).tagName === "w:tc") as Element[];
+    const p = cells0[0].getElementsByTagName("w:p")[0];
+    p.setAttribute("w14:paraId", "DEADBEEF");
+
+    const engine = new RedlineEngine(doc);
+    const res = engine.process_batch([
+      {
+        type: "delete_row",
+        target_text: "{#cell:DEADBEEF}",
+      } as any,
+    ]);
+
+    expect(res.edits_applied).toBe(1);
+  });
+});
+
+describe("Adeu MCP QA Report - Issue 5: Empty-cell fill spacing", () => {
+  it("TC 5.1: modifying cell anchor next to a label preserves or inserts a separator space", async () => {
+    const doc = await createTestDocument();
+    const tbl = addTable(doc, 1, 1);
+    const rows = Array.from(tbl.childNodes).filter((n) => (n as Element).tagName === "w:tr") as Element[];
+    const cells = Array.from(rows[0].childNodes).filter((n) => (n as Element).tagName === "w:tc") as Element[];
+    const tc = cells[0];
+
+    // Clear and construct a paragraph with text "Nimi" and paraId "DEADBEEF"
+    while (tc.firstChild) tc.removeChild(tc.firstChild);
+    const xmlDoc = doc.element.ownerDocument!;
+    const p = xmlDoc.createElement("w:p");
+    p.setAttribute("w14:paraId", "DEADBEEF");
+    const r = xmlDoc.createElement("w:r");
+    const t = xmlDoc.createElement("w:t");
+    t.textContent = "Nimi";
+    r.appendChild(t);
+    p.appendChild(r);
+    tc.appendChild(p);
+
+    const engine = new RedlineEngine(doc);
+    const res = engine.process_batch([
+      {
+        type: "modify",
+        target_text: "{#cell:DEADBEEF}",
+        new_text: "Testi Testinen",
+      } as any,
+    ]);
+
+    expect(res.edits_applied).toBe(1);
+
+    (engine as any).accept_all_revisions();
+    const cleanText = await extractTextFromBuffer(await doc.save(), true);
+    // It should have some separator, e.g. "Nimi Testi Testinen" instead of "NimiTesti Testinen"
+    expect(cleanText).not.toContain("NimiTesti Testinen");
+  });
+});
+
+describe("Adeu MCP QA Report - Issue 7: finalize_document keep-markup comments section label", () => {
+  it("TC 7.1: keep-markup with open comments does NOT label them as COMMENTS (stripped)", async () => {
+    const doc = await createTestDocument();
+    addParagraph(doc, "This is a normal paragraph.");
+
+    const engine = new RedlineEngine(doc);
+    const res = engine.process_batch([
+      {
+        type: "modify",
+        target_text: "This is a normal paragraph.",
+        new_text: "This is a normal paragraph.",
+        comment: "This is a comment",
+      } as any,
+    ]);
+    expect(res.edits_applied).toBe(1);
+
+    const finalizeRes = await finalize_document(doc, {
+      filename: "test.docx",
+      sanitize_mode: "keep-markup",
+    });
+
+    const report = finalizeRes.reportText;
+
+    // The report must NOT contain the contradictory "COMMENTS (stripped)" header
+    // when comments are actually kept (0 comments removed, 1 comment kept).
+    expect(report).not.toContain("COMMENTS (stripped)");
+  });
+});