TL;DR: Detect the language of each version before diffing, and refuse to diff across languages. Compare the translation against its own prior translated version, or diff the source-language versions only. The agent was diffing English against French, so every sentence registered as changed.

```text
agent diffed the English version against the translated version  -  the counterparty sent the French execution copy and the agent treated translation as edits
```

1. Confirm the language mismatch. Run language detection on both input files (or check the first page by eye). Expected: the two files are in different languages, which fully explains a whole-document diff.

2. Stop the cross-language diff. Add a pre-diff language check: if the detected languages differ, abort with "language mismatch" instead of producing a diff. Expected: no future run can silently diff English against French again.

3. Find the correct comparison pair. Either locate the prior French version and diff French against French, or diff the English draft lineage only. Expected: a same-language pair whose diff reflects actual negotiation changes.

4. If no prior translated version exists, say so explicitly. Report "French execution copy received; no prior French version to compare against" and summarize the translation on its own terms instead of as a diff. Expected: an honest standalone summary replaces the misleading whole-document "rewrite" diff.

5. Record language as version metadata going forward. Every ingested version gets a detected-language tag stored alongside it. Expected: the pipeline can select same-language pairs automatically and flag mismatches at ingest time.

## Use this when
- a version diff reports the entire document as changed and the versions are in different languages
- the counterparty sent an execution copy in another language
- the agent's redline summary describes translation differences as negotiated edits
- multilingual deal teams produce version chains in two or more languages

## Not for this skill when
- both versions are the same language and the diff is still noisy (check format mismatch, OCR, or reflow instead)
- you need a translation-quality check (that is a different task: compare the translation against the source for fidelity, not as a redline)
- the "translation" is actually a restatement with substantive changes (diff same-language versions first, then assess the restated terms separately)

## Variant phrasings
- agent treated the French execution copy as edits to the English draft
- cross-language diff reported the whole contract as rewritten
- version comparison compared English against the translated version
- redline flagged translation as contract changes

## Why it happens
Diff tools compare strings, not meaning. A translated sentence shares almost no tokens with its source, so a whole-document diff is the "correct" output of a tool asked a meaningless question. The failure is upstream: nothing verified the two inputs were comparable before the diff ran, and "everything changed" looks like a plausible (if alarming) redline result.

## Edge cases
- Bilingual execution copies (two columns or two sections) need per-section language detection, not per-file. Diff the English sections against English and the French against French.
- The governing-language clause usually says which version prevails in a dispute. The agent should know this before summarizing either version.
- Machine-translating one side to enable a diff is tempting but lossy. It is fine for triage ("did anything big change?") but never for the authoritative redline; get the same-language pair instead.

## Provenance

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