@adeu/core 1.17.0 → 1.17.2

package/src/ingest.ts

@@ -184,13 +184,28 @@ export function extract_table(
 
       if (!first_cell) cell_cursor += 3;
 
-      const cell_content = _extract_blocks(
+      let cell_content = _extract_blocks(
         cell,
         comments_map,
         cleanView,
         cell_cursor,
         paragraph_offsets,
       );
+      // Emit a stable, document-native anchor for this cell so empty/short
+      // value cells are addressable by the engine. Reuses the {#...} bookmark
+      // projection (already protected by validate_edit_strings and resolvable
+      // 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
+          | Element
+          | undefined;
+        const paraId = firstP ? firstP.getAttribute("w14:paraId") : null;
+        if (paraId) {
+          const anchor = `{#cell:${paraId}}`;
+          cell_content = cell_content + anchor;
+        }
+      }
       cell_texts.push(cell_content);
       cell_cursor += cell_content.length;
       first_cell = false;

package/src/mapper.ts

@@ -260,7 +260,29 @@ export class DocumentMapper {
           current += 3;
         }
 
+        const cell_start = current;
         current = this._map_blocks(cell, current);
+
+        // Parity with ingest.extract_table: emit a {#cell:<paraId>} anchor and
+        // bind a zero-width span to the cell's first paragraph so the engine
+        // 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
+            | Element
+            | undefined;
+          const paraId = firstP ? firstP.getAttribute("w14:paraId") : null;
+          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 anchor = `{#cell:${paraId}}`;
+            this._add_virtual_text(anchor, current, cellPara);
+            current += anchor.length;
+          }
+        }
         cells_processed += 1;
       }
 
@@ -738,7 +760,7 @@ export class DocumentMapper {
     target_text = this._replace_smart_quotes(target_text);
 
     const parts: string[] = [];
-    const token_pattern = /(\[_+\])|(\s+)|(['"])|([.,;:\/])/g;
+    const token_pattern = /(\[_+\])|(\s+)|(['"])|([.,;:\/\-\[\](){}+=$?*!|#^<>\\%&@~`_])/g;
 
     let last_idx = 0;
     let match;

package/src/markup.test.ts

@@ -1,10 +1,11 @@
 import { describe, it, expect } from 'vitest';
-import { 
-  _replace_smart_quotes, 
-  _make_fuzzy_regex, 
-  _find_match_in_text, 
-  _build_critic_markup, 
-  apply_edits_to_markdown 
+import {
+  _replace_smart_quotes,
+  _make_fuzzy_regex,
+  _find_match_in_text,
+  _build_critic_markup,
+  apply_edits_to_markdown,
+  format_ambiguity_error
 } from './markup.js';
 import { ModifyText } from './models.js';
 
@@ -147,4 +148,38 @@ describe('apply_edits_to_markdown', () => {
     const result = apply_edits_to_markdown(text, [{ type: 'modify', target_text: target, new_text: newText }]);
     expect(result).toContain(expectedSubstring);
   });
+});
+
+describe('format_ambiguity_error (Turn Loop Trap mitigation)', () => {
+  // Mirror the DPA scenario: the same placeholder appears in multiple clauses.
+  const haystack =
+    'PROVIDER: [official company name] shall process the data. ' +
+    'PROVIDER: [official company name] is the data processor.';
+  const target = 'PROVIDER: [official company name]';
+  const positions: [number, number][] = [
+    [0, target.length],
+    [58, 58 + target.length],
+  ];
+
+  it('names BOTH match_mode escape hatches so the agent can re-call instead of looping', () => {
+    const msg = format_ambiguity_error(1, target, haystack, positions);
+
+    expect(msg).toContain('Edit 1 Failed: Ambiguous match');
+    expect(msg).toContain('appears 2 times');
+
+    // The actionable remediation that breaks the loop.
+    expect(msg).toContain('"match_mode": "all"');
+    expect(msg).toContain('"match_mode": "first"');
+    expect(msg).toContain('ALL 2 occurrences');
+    expect(msg).toContain('FIRST occurrence');
+
+    // The original "add more context" guidance is preserved as a third option.
+    expect(msg).toContain('Please provide more surrounding context');
+  });
+
+  it('still throws for fewer than two matches', () => {
+    expect(() => format_ambiguity_error(1, target, haystack, [[0, 5]])).toThrow(
+      /requires at least 2 matches/,
+    );
+  });
 });

package/src/markup.ts

@@ -138,7 +138,7 @@ export function _make_fuzzy_regex(target_text: string): string {
   target_text = _replace_smart_quotes(target_text);
 
   const parts: string[] = [];
-  const token_pattern = /(_+)|(\s+)|(['"])|([.,;:\/])/g;
+  const token_pattern = /(_+)|(\s+)|(['"])|([.,;:\/\-\[\](){}+=$?*!|#^<>\\%&@~`])/g;
 
   // Note: JS does not support atomic groups (?>...).
   // However, because we only match markdown characters * and _,
@@ -422,8 +422,19 @@ export function format_ambiguity_error(
     lines.push(`    ... and ${remaining} more occurrence(s) not shown.`);
   }
 
+  // Tell the agent EXACTLY how to re-call. Without this, agents loop forever
+  // refining target_text/regex because they never learn that match_mode is the
+  // built-in escape hatch for genuine ambiguity.
+  lines.push("  To resolve, re-send this edit using ONE of these strategies:");
   lines.push(
-    "  Please provide more surrounding context in your target_text to uniquely identify the location.",
+    `    1. Set "match_mode": "all" to modify ALL ${total} occurrences (same target_text).`,
+  );
+  lines.push(
+    '    2. Set "match_mode": "first" to modify only the FIRST occurrence (same target_text).',
+  );
+  lines.push(
+    '    3. Please provide more surrounding context in your target_text to uniquely ' +
+      'identify a single location (keep the default "match_mode": "strict").',
   );
 
   return lines.join("\n");

package/src/repro.feedback.test.ts

@@ -0,0 +1,160 @@
+// FILE: node/packages/core/src/repro.feedback.test.ts
+//
+// Regression repros for the field observations against the Node engine.
+//
+// STYLE: these assert the DESIRED (correct) behaviour, so a test is RED while
+// the bug is present and turns GREEN once the engine is fixed. (This is the
+// "isolate the bug before fixing" pattern from AI_CONTEXT.md > Testing.)
+//
+//   Issue 1 — accept + modify the same span in one batch  -> currently RED (bug)
+//   Issue 2 — comment-only run-shredding                  -> NOT a bug; see note
+//
+// (Issue 3 lives in node/packages/mcp-server/src/repro.feedback.test.ts.)
+
+import { describe, it, expect } from "vitest";
+import { RedlineEngine } from "./engine.js";
+import { createTestDocument, addParagraph } from "./test-utils.js";
+
+/** Append a paragraph that already contains a tracked insertion by `author`. */
+function addParagraphWithForeignInsertion(
+  doc: any,
+  prefix: string,
+  insertedText: string,
+  insId: string,
+  author: string,
+): Element {
+  const x = doc.element.ownerDocument!;
+  const p = x.createElement("w:p");
+  const r0 = x.createElement("w:r");
+  const t0 = x.createElement("w:t");
+  t0.textContent = prefix;
+  t0.setAttribute("xml:space", "preserve");
+  r0.appendChild(t0);
+  p.appendChild(r0);
+
+  const ins = x.createElement("w:ins");
+  ins.setAttribute("w:id", insId);
+  ins.setAttribute("w:author", author);
+  ins.setAttribute("w:date", "2024-01-01T00:00:00Z");
+  const r = x.createElement("w:r");
+  const t = x.createElement("w:t");
+  t.textContent = insertedText;
+  r.appendChild(t);
+  ins.appendChild(r);
+  p.appendChild(ins);
+
+  doc.element.appendChild(p);
+  return p;
+}
+
+function countTag(el: any, tag: string): number {
+  let n = 0;
+  const walk = (node: any) => {
+    if (node.tagName === tag) n++;
+    let c = node.firstChild;
+    while (c) {
+      if (c.nodeType === 1) walk(c);
+      c = c.nextSibling;
+    }
+  };
+  walk(el);
+  return n;
+}
+
+describe("Field feedback repro — Node engine", () => {
+  // ───────────────────────────────────────────────────────────────────────
+  // ISSUE 1 — RED until fixed.
+  //
+  // Accepting a foreign author's insertion and then editing that now-accepted
+  // text, in a SINGLE batch, MUST succeed: by the time the modify runs the span
+  // has been accepted and is no longer foreign. Node rejects it because the
+  // unified up-front validation pass (engine.ts `_process_batch_internal`, the
+  // `validate_edits(edits)` call BEFORE `apply_review_actions`) validates the
+  // modify against the PRE-accept document. This test fails today and will pass
+  // once validation runs after the accepts are applied.
+  // ───────────────────────────────────────────────────────────────────────
+  it("Issue 1: accept + modify of the SAME foreign insertion in one batch should succeed", async () => {
+    const doc = await createTestDocument();
+    addParagraphWithForeignInsertion(
+      doc,
+      "The term is ",
+      "24 months",
+      "5",
+      "Supplier's Counsel",
+    );
+
+    const engine = new RedlineEngine(doc, "Acme's Counsel");
+    const batch = [
+      { type: "accept", target_id: "Chg:5" },
+      { type: "modify", target_text: "24 months", new_text: "36 months" },
+    ] as any[];
+
+    // DESIRED behaviour — RED on current Node (throws "active insertion from
+    // another author"), GREEN after the fix.
+    const stats = engine.process_batch(batch, false);
+    expect(stats.actions_applied).toBe(1);
+    expect(stats.edits_applied).toBe(1);
+    expect(stats.edits_skipped).toBe(0);
+  });
+
+  it("Issue 1 (control, GREEN): the same accept + modify succeeds across two batches", async () => {
+    // Proves the rejection above is purely a single-round-trip batching
+    // artifact — the content and intent are valid.
+    const doc = await createTestDocument();
+    addParagraphWithForeignInsertion(
+      doc,
+      "The term is ",
+      "24 months",
+      "5",
+      "Supplier's Counsel",
+    );
+
+    const engine = new RedlineEngine(doc, "Acme's Counsel");
+    const r1 = engine.process_batch([{ type: "accept", target_id: "Chg:5" }], false);
+    expect(r1.actions_applied).toBe(1);
+    const r2 = engine.process_batch(
+      [{ type: "modify", target_text: "24 months", new_text: "36 months" }],
+      false,
+    );
+    expect(r2.edits_applied).toBe(1);
+  });
+
+  // ───────────────────────────────────────────────────────────────────────
+  // ISSUE 2 — NOT a bug in the current engine, so there is nothing to fail on.
+  // The described mechanism (one match whose physical runs are shredded →
+  // comment id duplicated per run segment) does not occur: COMMENT_ONLY anchors
+  // a single range across the first→last run regardless of fragmentation. These
+  // assertions are GREEN BY DESIGN and exist as evidence for the "not
+  // replicable" conclusion. (The real gap — no dedicated comment-only change
+  // type, so comments must ride a self-replacing ModifyText — is a feature
+  // request, not a failing-test-able defect.)
+  // ───────────────────────────────────────────────────────────────────────
+  it("Issue 2 (GREEN, evidence): self-replacement comment over 9 fragmented runs emits ONE comment", async () => {
+    const doc = await createTestDocument();
+    const x = doc.element.ownerDocument!;
+    const p = x.createElement("w:p");
+    const words = [
+      "The ", "Purchase ", "Price ", "is ", "[   ] ",
+      "dollars ", "per ", "unit ", "total.",
+    ];
+    words.forEach((w, i) => {
+      if (i % 2 === 0) p.appendChild(x.createElement("w:proofErr"));
+      const r = x.createElement("w:r");
+      const t = x.createElement("w:t");
+      t.textContent = w;
+      t.setAttribute("xml:space", "preserve");
+      r.appendChild(t);
+      p.appendChild(r);
+    });
+    doc.element.appendChild(p);
+
+    const engine = new RedlineEngine(doc, "Reviewer");
+    const sentence = words.join("").trim();
+    engine.process_batch(
+      [{ type: "modify", target_text: sentence, new_text: sentence, comment: "Missing value" }],
+      false,
+    );
+
+    expect(countTag(doc.element, "w:commentReference")).toBe(1);
+  });
+});

package/src/repro.report.test.ts

@@ -0,0 +1,130 @@
+import { describe, it, expect } from "vitest";
+import { createTestDocument, addParagraph, addTable, setCellText } from "./test-utils.js";
+import { RedlineEngine } from "./engine.js";
+import { DocumentObject } from "./docx/bridge.js";
+
+describe("Webinar Report Bug Reproductions", () => {
+  it("Bug 1: Diff Engine Fragility (Token-Splitting Punctuation)", async () => {
+    const doc = await createTestDocument();
+    const xmlDoc = doc.element.ownerDocument!;
+    const p = xmlDoc.createElement("w:p");
+
+    // Replicate MS Word fragmented runs for token-splitting punctuation: [Company Name]
+    // with style/formatting run fragmentation where only some runs are bold.
+    // This generates: **[**Company Name**]**
+    // The target "[Company Name]" will fail to be matched because brackets are not treated
+    // as fuzzy boundaries, so the fuzzy regex expects "[Company" directly without the intermediate "**".
+    const r1 = xmlDoc.createElement("w:r");
+    const rPr1 = xmlDoc.createElement("w:rPr");
+    rPr1.appendChild(xmlDoc.createElement("w:b"));
+    r1.appendChild(rPr1);
+    const t1 = xmlDoc.createElement("w:t");
+    t1.textContent = "[";
+    r1.appendChild(t1);
+    p.appendChild(r1);
+
+    const r2 = xmlDoc.createElement("w:r");
+    // Run 2 is NOT bold
+    const t2 = xmlDoc.createElement("w:t");
+    t2.textContent = "Company Name";
+    r2.appendChild(t2);
+    p.appendChild(r2);
+
+    const r3 = xmlDoc.createElement("w:r");
+    const rPr3 = xmlDoc.createElement("w:rPr");
+    rPr3.appendChild(xmlDoc.createElement("w:b"));
+    r3.appendChild(rPr3);
+    const t3 = xmlDoc.createElement("w:t");
+    t3.textContent = "]";
+    r3.appendChild(t3);
+    p.appendChild(r3);
+
+    doc.element.appendChild(p);
+
+    const engine = new RedlineEngine(doc);
+
+    // Under correct engine behavior, targeting "[Company Name]" should succeed.
+    // However, on the unpatched codebase, it throws a BatchValidationError (Target text not found).
+    const res = engine.process_batch([
+      {
+        type: "modify",
+        target_text: "[Company Name]",
+        new_text: "Google LLC",
+      } as any,
+    ]);
+
+    expect(res.edits_applied).toBe(1);
+    expect(res.edits_skipped).toBe(0);
+  });
+
+  it("Bug 2: Revision History Lockouts (Active Insertion Collisions)", async () => {
+    const doc = await createTestDocument();
+    const xmlDoc = doc.element.ownerDocument!;
+    
+    const p = addParagraph(doc, "The party shall provide ");
+    const ins = xmlDoc.createElement("w:ins");
+    ins.setAttribute("w:id", "123");
+    ins.setAttribute("w:author", "Supplier's Counsel");
+    const r = xmlDoc.createElement("w:r");
+    const t = xmlDoc.createElement("w:t");
+    t.textContent = "written notice";
+    r.appendChild(t);
+    ins.appendChild(r);
+    p.appendChild(ins);
+
+    const suffixRun = xmlDoc.createElement("w:r");
+    const suffixText = xmlDoc.createElement("w:t");
+    suffixText.textContent = " within 30 days.";
+    suffixRun.appendChild(suffixText);
+    p.appendChild(suffixRun);
+
+    // Create an engine with a different user name to trigger co-authoring lockout
+    const engine = new RedlineEngine(doc, "Reviewer");
+
+    // Standard edit targeting the paragraph text containing the active insertion
+    const edit = {
+      type: "modify",
+      target_text: "written notice within 30 days.",
+      new_text: "notice within 15 business days.",
+    };
+
+    // Under normal collaborative conditions, this edit should succeed.
+    // However, on the current unpatched codebase, the dry-run engine aborts with a BatchValidationError.
+    const res = engine.process_batch([edit as any], true);
+    expect(res.edits_applied).toBe(1);
+  });
+
+  it("Bug 3: Table Layout Ambiguity and Markdown Loss of Fidelity", async () => {
+    const doc = await createTestDocument();
+    
+    // Create a table with 2 rows, 4 columns
+    const tbl = addTable(doc, 2, 4);
+    
+    // Set cell text to match identical structure: Date | | | 
+    setCellText(tbl, 0, 0, "Date");
+    setCellText(tbl, 0, 1, "");
+    setCellText(tbl, 0, 2, "");
+    setCellText(tbl, 0, 3, "");
+    
+    setCellText(tbl, 1, 0, "Date");
+    setCellText(tbl, 1, 1, "");
+    setCellText(tbl, 1, 2, "");
+    setCellText(tbl, 1, 3, "");
+
+    const buf = await doc.save();
+    const midDoc = await DocumentObject.load(buf);
+    const engine = new RedlineEngine(midDoc);
+
+    // Target one of the empty rows to apply a date.
+    const edit = {
+      type: "modify",
+      target_text: "Date |  |  | ",
+      new_text: "Date | June 29, 2026 |  | ",
+    };
+
+    // Ideally, the system should allow distinct targeting of cells (e.g. preserving grid coordinates).
+    // But due to the coordinate-flattening design flaw, it throws "Ambiguous match".
+    const res = engine.process_batch([edit as any]);
+    expect(res.edits_applied).toBe(1);
+  });
+});

package/src/repro_qa_report_v3.test.ts

@@ -0,0 +1,194 @@
+import { describe, it, expect } from "vitest";
+import { createTestDocument, addParagraph } from "./test-utils.js";
+import { RedlineEngine } from "./engine.js";
+
+describe("QA Report V3 Defects Reproductions", () => {
+  it("TC1: Sequential batch evaluation (modify->modify chaining) [report F1]", async () => {
+    const doc = await createTestDocument();
+    addParagraph(doc, "As defined in Section 1, the Recipient shall maintain confidentiality of all materials.");
+    const engine = new RedlineEngine(doc);
+
+    // If sequential evaluation works (like Python), the second edit will find "Receiving Party" (the output of the first edit).
+    // On the current unpatched Node engine, this will FAIL and throw "Target text not found in document: Receiving Party".
+    const res = engine.process_batch([
+      {
+        type: "modify",
+        target_text: "the Recipient",
+        new_text: "Receiving Party",
+      } as any,
+      {
+        type: "modify",
+        target_text: "Receiving Party",
+        new_text: "Disclosee",
+      } as any,
+    ]);
+
+    expect(res.edits_applied).toBe(2);
+    expect(res.edits_skipped).toBe(0);
+  });
+
+  it("TC2: NODE dry-run ≠ real write (active-insertion guard) [report F2, F3]", async () => {
+    const doc = await createTestDocument();
+    const xmlDoc = doc.element.ownerDocument!;
+
+    // Create a paragraph with an active insertion by "Original Drafter"
+    const p = addParagraph(doc, "The party shall provide ");
+    const ins = xmlDoc.createElement("w:ins");
+    ins.setAttribute("w:id", "101");
+    ins.setAttribute("w:author", "Original Drafter");
+    ins.setAttribute("w:date", "2026-06-29T12:00:00Z");
+    
+    const r = xmlDoc.createElement("w:r");
+    const t = xmlDoc.createElement("w:t");
+    t.textContent = "five (5)";
+    r.appendChild(t);
+    ins.appendChild(r);
+    p.appendChild(ins);
+
+    const suffixRun = xmlDoc.createElement("w:r");
+    const suffixText = xmlDoc.createElement("w:t");
+    suffixText.textContent = " years.";
+    suffixRun.appendChild(suffixText);
+    p.appendChild(suffixRun);
+
+    // Create an engine with a different user name ("QA Tester") to trigger lockout
+    const engine = new RedlineEngine(doc, "QA Tester");
+
+    const edit = {
+      type: "modify",
+      target_text: "five (5)",
+      new_text: "seven (7)",
+    } as any;
+
+    // Run A: dry_run = true
+    const resDry = engine.process_batch([edit], true);
+    expect(resDry.edits_applied).toBe(0);
+    expect(resDry.edits_skipped).toBe(1);
+    expect(resDry.edits[0].status).toBe("failed");
+    expect(resDry.edits[0].error).toContain("active insertion");
+
+    // Run B: dry_run = false
+    let wetRunError: any = null;
+    try {
+      engine.process_batch([edit], false);
+    } catch (e) {
+      wetRunError = e;
+    }
+
+    expect(wetRunError).not.toBeNull();
+    expect(wetRunError.name).toBe("BatchValidationError");
+    expect(wetRunError.message).toContain("active insertion");
+  });
+
+  it("TC3: Heading targeted by markdown '#' corrupts instead of failing [report F4, F5]", async () => {
+    const doc = await createTestDocument();
+    const xmlDoc = doc.element.ownerDocument!;
+
+    // Create a styled heading "3. Pending Review" (without literal "#" in the Word doc) using Heading1 style
+    const p = xmlDoc.createElement("w:p");
+    const pPr = xmlDoc.createElement("w:pPr");
+    const pStyle = xmlDoc.createElement("w:pStyle");
+    pStyle.setAttribute("w:val", "Heading1");
+    pPr.appendChild(pStyle);
+    p.appendChild(pPr);
+
+    const r = xmlDoc.createElement("w:r");
+    const t = xmlDoc.createElement("w:t");
+    t.textContent = "3. Pending Review";
+    r.appendChild(t);
+    p.appendChild(r);
+    doc.element.appendChild(p);
+
+    const engine = new RedlineEngine(doc);
+
+    // Target by its markdown representation
+    const res = engine.process_batch([
+      {
+        type: "modify",
+        target_text: "# 3. Pending Review",
+        new_text: "# 3. Final Review",
+      } as any,
+    ]);
+
+    expect(res.edits_applied).toBe(1);
+
+    // The correct behavior must NOT produce a redline containing a literal '#' character in the CriticMarkup preview
+    // or body text (such as `{--# 3. Pending--}{++# 3. Final++} Review`).
+    // Asserting that the critic_markup does NOT contain "{--#" or "{++#" will fail precisely due to this bug.
+    const criticMarkup = res.edits[0].critic_markup;
+    expect(criticMarkup).not.toContain("{--#");
+    expect(criticMarkup).not.toContain("{++#");
+  });
+
+  it("TC5: w16du namespace stamped on untouched parts [report F9]", async () => {
+    const doc = await createTestDocument();
+    addParagraph(doc, "This is untouched body text.");
+
+    // Inject a header part without w16du namespace
+    const headerXml = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+      <w:hdr xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
+        <w:p><w:r><w:t>Header Text</w:t></w:r></w:p>
+      </w:hdr>`;
+    const headerPart = doc.pkg.addPart(
+      "/word/header1.xml",
+      "application/vnd.openxmlformats-officedocument.wordprocessingml.header+xml",
+      headerXml,
+    );
+    doc.relateTo(
+      headerPart,
+      "http://schemas.openxmlformats.org/officeDocument/2006/relationships/header",
+    );
+
+    const engine = new RedlineEngine(doc);
+    engine.process_batch([
+      {
+        type: "modify",
+        target_text: "untouched body",
+        new_text: "changed body",
+      } as any,
+    ]);
+
+    // Save the package to trigger serialization of all parts
+    await doc.save();
+
+    // Verify the header XML does not contain the word16du namespace
+    const savedHeaderXml = headerPart._element.toString();
+    expect(savedHeaderXml).not.toContain("word16du");
+  });
+
+  it("TC8: Error message mislabels edit index [report F7]", async () => {
+    const doc = await createTestDocument();
+    addParagraph(doc, "First paragraph text.");
+
+    const engine = new RedlineEngine(doc);
+
+    // Run in dry_run mode where the bug manifests.
+    // Edit 1 succeeds, Edit 2 fails because "Non-existent text" is not found.
+    // On the unpatched codebase, individual validation of edit 2 passes single_errors = validate_edits([edit]),
+    // which hardcodes i = 0 internally. Thus, the error in res.edits[1].error is:
+    // "- Edit 1 Failed: Target text not found..." instead of "- Edit 2 Failed: ...".
+    const res = engine.process_batch([
+      {
+        type: "modify",
+        target_text: "First paragraph",
+        new_text: "Updated first paragraph",
+      } as any,
+      {
+        type: "modify",
+        target_text: "Non-existent text",
+        new_text: "Failed update",
+      } as any,
+    ], true);
+
+    expect(res.edits_applied).toBe(1);
+    expect(res.edits_skipped).toBe(1);
+    expect(res.edits[1].status).toBe("failed");
+    
+    // Assert that the error message correctly labels it as Edit 2.
+    // The buggy unpatched codebase says "Edit 1 Failed:" inside the error message for Edit 2.
+    const errorMsg = res.edits[1].error;
+    expect(errorMsg).toContain("Edit 2 Failed:");
+    expect(errorMsg).not.toContain("Edit 1 Failed:");
+  });
+});
+