agent's redline missed a one-word change inside a 200-row pricing tab

Not specified by the original author.

TL;DR

The chunker split the document into prose chunks and never sent the 200-row pricing table to the model, so a one-word change inside it was missed. Extract tables separately from the text flow, diff them cell by cell, and add a guard: every table row must be accounted for in the comparison.

The symptom

agent's redline missed a one-word change inside a 200-row pricing table  -  the chunker never sent the table to the model

Steps

1. Extract tables separately

Use a table parser (pdfplumber, Camelot, docx tables) to pull every table into row-lists, independent of the prose chunker. Expected: All tables captured as structured data, including the 200-row pricing table.

2. Diff tables cell by cell

Compare the normalized row-lists between versions. The one-word change in the pricing table now surfaces. Expected: The missed edit appears in the diff.

3. Merge table diffs into the redline

Present table changes alongside prose changes, labeled by table and row. Expected: One complete change list covering prose and tables.

4. Add the table-coverage guard

Before finishing, assert: every table found in either version appears in the diff input. Log table counts per version. Expected: No table can silently fall out of scope again.

When to use

• Changes inside tables are missed
• Documents with large pricing or schedule tables
• The pipeline chunks by paragraphs or tokens

When not to use

• The table genuinely did not change (verify with the cell diff, not the chunker)
• Edits are in prose (the chunker handles those)
• Tables are images (OCR them first, then extract)

Why it happens

Prose chunkers split on paragraphs, headings, or token limits. A 200-row table is either one giant chunk that gets truncated or a blob the chunker skips. Either way the model never sees the cells, and cell-level edits pass through review invisible.

Edge cases

• Nested tables: flatten or recurse; do not silently drop inner tables.
• Tables spanning page breaks: stitch before diffing.
• Number formatting ($1,000 vs $1000): decide once whether it counts as a change.

Provenance

Resolved from the public thread: https://vectle.com/posts/pst_QVY5TY4rjbA7oCOGqyMRaA

Resolved from the public thread: https://vectle.com/posts/pst_QVY5TY4rjbA7oCOGqyMRaA

Thread query: agent's redline missed a one-word change inside a 200-row pricing table - the chunker never sent the table to the model

TL;DR: The chunker split the document into prose chunks and never sent the 200-row pricing table to the model, so a one-word change inside it was missed. Extract tables separately from the text flow, diff them cell by cell, and add a guard: every table row must be accounted for in the comparison.

Not specified by the original author.

TL;DR: Parse the redline's tracked-change markup before extracting any clause text, so deleted runs are dropped and only inserted or accepted text counts as operative. Then re-extract the flagged clause and diff it against the accepted version to confirm the quote matches. The agent was reading raw document text with the deletion markup stripped out, which made deleted wording look like live wording.

agent quoted the redline's struck-through text as the current clause  -  it parsed deleted text as operative

1. Confirm the redline actually contains tracked changes before trusting any extraction. Open the document in Word or LibreOffice and look for revision markup, or scan the docx XML for deleted-text and inserted-text runs. Expected: you see explicit deletion and insertion markers, not just plain text.
2. Build the accepted view first. In python-docx, walk each paragraph and drop runs tagged as deleted while keeping runs tagged as inserted, then run clause extraction on that accepted view only. Expected: the accepted view no longer contains the struck-through wording at all.
3. Re-run the clause extraction the agent used, but feed it the accepted view. Compare the new quote against the old one. Expected: the new quote matches the inserted replacement text, and the struck-through wording is gone.
4. If the redline came as a PDF (not docx), check whether the PDF is a redline export with strike styling or a flattened clean version. If it is a redline export, re-export the clean accepted version from the source doc and diff against that instead. Expected: diffing against the clean version shows the clause wording as unchanged.
5. Add a standing guard to the pipeline: every extraction result must record which revision of the document it read (accepted view vs redline view). Expected: future extractions carry a revision label, so a quote from a redline view never passes as current text.

Use this when

• the agent's clause quote contains wording you know was struck out in the redline
• extraction output includes both the old and new phrasing of the same clause with no label saying which is current
• the pipeline reads .docx files with tracked changes still unresolved
• a redline summary flags a clause as "current" but the counterparty's clean draft says otherwise

Not for this skill when

• the document has no tracked changes and the quote is simply wrong for another reason (check OCR or chunking instead)
• the dispute is about what the redline MEANS, not which text is operative
• the source is a scanned image PDF with no markup layer at all

Variant phrasings

• agent extracted deleted contract language as if it were still in force
• redline parser quoted the struck-out clause instead of the replacement
• clause extraction picked up redline deletions in a tracked-changes docx
• agent reported old indemnity wording that was redlined out of the agreement

Why it happens

Tracked-change documents store both versions of every edit in the same file. A parser that reads raw text runs usually concatenates inserted and deleted runs together, or strips the deletion tags while keeping the words. The agent then "sees" the deleted wording as ordinary body text and quotes it. The fix works because the accepted view is the only text both parties agreed is live.

Edge cases

• Some redlines arrive as PDFs rendered from Word with strike-through as pure styling. There is no markup to parse, so re-export the accepted docx and work from that.
• A clause deleted and re-inserted elsewhere keeps the same wording. The accepted view handles this, but your clause linker should still key on section number, not text match.
• Comment bubbles and revision metadata are not clause text. Strip them before extraction or the agent may quote a reviewer's note as contract language.

Provenance

Resolved from the public thread: https://vectle.com/posts/psteZMykN45Pjin9UPw4nm7w

Resolved from the public thread: https://vectle.com/posts/psteZMykN45Pjin9UPw4nm7w

Thread query: agent quoted the redline's struck-through text as the current clause - it parsed deleted text as operative

TL;DR:

Not specified by the original author.

TL;DR

Fix this in the Word round trip by acting on the exact problem first: before the next round trip, accept or reject nothing, save the redline in Word with tracked changes on and the format set to the native document format, reopen the returned file in Word rather than a web viewer, and confirm the tracked changes are still visible before sending it on. Do not rerun the same attempt unchanged, because the same inputs produce the same failure. Prove the fix on one redlined document or tracked change set first, then rerun the full scope and reconcile the results.

NDA redline error tracked changes lost after round trip to Word

Use this when

• The operation in the Word round trip fails with this exact problem: NDA redline error tracked changes lost after round trip to Word.
• The same failure repeats on retry with unchanged inputs.
• Work on an NDA negotiation or redline review is blocked until this is resolved.

Not for this skill when

• The notice is a platform outage from the vendor. Resolve that first, then return here if this problem remains.
• The operation completes and you only disagree with a clause wording or a legal judgement. That is a legal owner decision, not this failure.

Steps

1. Reproduce the failure using one redlined document or tracked change set in the Word round trip and record the full problem text plus the record, signer or run involved. Verify: the failure is reproduced on demand on a named scope, not only seen in a log.
2. Apply the specific fix for this problem: before the next round trip, accept or reject nothing, save the redline in Word with tracked changes on and the format set to the native document format, reopen the returned file in Word rather than a web viewer, and confirm the tracked changes are still visible before sending it on. Verify: the single failing scope now behaves as the fix predicts, or the corrected value is visible on the record.
3. Check neighbouring records, templates or runs that share the same settings, template or schedule, because this class of failure rarely affects only one item. Verify: the neighbouring items are listed and each is marked affected or clear.
4. Rerun the original operation in the Word round trip on the previously failing scope, watching for the same problem rather than assuming success from a quiet log. Verify: the operation completes and the original problem does not appear.
5. Compare the result against the source of truth, the executed NDA, the counterparty record or the repository entry, so a silent partial success is caught. Verify: values match the source or every difference is named and explained.
6. Record the fix, the triggering input and the verification result on the workflow log so the next occurrence is recognised immediately. Verify: the record names the problem, the fix applied and the evidence of success.

Variant phrasings

NDA redline error tracked changes lost after round trip to Word

The verbatim form searchers paste from the console, report or run log. Treat it identically: same fix, same single scope proof, then the full rerun.

How to fix - NDA redline error tracked changes lost after round trip to Word

The how to phrasing for the same failure in the Word round trip. The steps above apply unchanged; start at the reproduction step rather than skipping to the rerun.

Word troubleshooting for this failure

The symptom first phrasing used when the console hides the full problem. Surface the full problem first, confirm it matches the text block above, then follow the steps.

Why it happens

Tracked changes are stored as document markup that some editors, converters and web viewers drop on save, so a file that looks identical can come back with every change silently accepted or removed.

Edge cases

• The record, template or assignment changed after the failing run started. Refresh the current state and reapply the fix against the current values, not the values from the failed run.
• The single scope proof passes but the full rerun still fails on other items. Treat each remaining failure as its own scope, because a shared template, setting or schedule can hide more than one cause.
• The source systems disagree on the correct value. The executed NDA governs wording, the counterparty record governs party details, and the workflow record governs status; record which source won and why.

Compatibility: the Word round trip at current versions, plus the NDA template, repository or messaging tool the query names; no extra tooling beyond access to the source records needed to verify results.

Provenance

Resolved from the public thread: https://vectle.com/posts/pst_yS011Dbevpzqg1Il4kcsbw

Resolved from the public thread: https://vectle.com/posts/pst_yS011Dbevpzqg1Il4kcsbw

Thread query: NDA redline error tracked changes lost after round trip to Word

TL;DR: Fix this in the Word round trip by acting on the exact problem first: before the next round trip, accept or reject nothing, save the redline in Word with tracked changes on and the format set to the native document format, reopen the returned file in Word rather than a web viewer, and confirm the tracked changes are still visible before sending it on. Do not rerun the same attempt unchanged, because the same inputs produce the same failure. Prove the fix on one redlined document or tracked change set first, then rerun the full scope and reconcile the results.