Ouvrez les deux documents Word pour suivre une première revue complète. Dans l’accord pilote reçu, Example Buyer dispose de trois jours ouvrés pour examiner un rapport. La copie de travail propose dix jours, cite la règle de l’exercice en commentaire et laisse le renouvellement à la décision du juriste. Les deux fichiers contiennent le même tableau des livrables.
Examiner l’exemple fictif
Téléchargez l’accord reçu et la copie de travail, ou utilisez le ZIP pour obtenir aussi les instructions et le script de vérification. L’exemple est en anglais dans les six éditions de ce guide. Vous pouvez l’examiner localement sans compte Claude ni document client.
Conservez l’original intact. Ouvrez la copie de travail dans Word et affichez toutes les marques et tous les commentaires. Dans la clause 2, repérez la suppression de « three » et l’insertion de « ten ». Le commentaire associé cite REVIEW-01 et demande au juriste de vérifier le délai au regard du calendrier du pilote.
Lisez la clause 3. Le texte du renouvellement reste intact, y compris le préavis de cinq jours. Le second commentaire, HOLD-01, demande une décision car le guide de l’exercice ne prévoit aucune position sur le renouvellement. La clause 1 et le tableau des livrables ne comportent aucune modification proposée.
Créez deux copies de test du fichier de travail. Refusez les deux modifications dans l’une et vérifiez que la phrase correspond à l’original. Acceptez les deux dans l’autre et confirmez que seul le délai change. Examinez les commentaires séparément. Masquer les marques ne tranche pas une modification. Instructions de Microsoft pour Word
Vérifier les éléments préservés
Depuis le ZIP décompressé, lancez python3 verify_sample.py. Python 3 lit les deux fichiers d’exemple localement. En cas de succès, le résultat commence par PASS: one replacement, two anchored comments. Le script vérifie l’insertion et la suppression natives, les ancrages et références des commentaires et le corps du document après simulation de chaque décision. Il compare également le tableau, les styles et les autres éléments du paquet à l’original.
Lisez examples/review-notes.md avec les documents. Ses trois entrées distinguent une clause intacte, un remplacement proposé et une décision en suspens. Les fichiers ont été préparés hors ligne, rendus pour contrôler leur mise en page et vérifiés structurellement. Cette vérification porte sur les deux fichiers livrés. Elle ne prouve ni que Claude préserve tout document ni que les termes conviennent à un contrat réel.
Utiliser les instructions sur un dossier autorisé
Choisissez ce workflow si un juriste a approuvé un référentiel pour ce type d’accord et si une personne désignée peut examiner chaque modification. Si le projet comporte des révisions en suspens, des annexes contradictoires, une définition manquante ou une clause inconnue, conservez l’original et soumettez ces questions avant de proposer une rédaction.
SKILL.md décrit la procédure. Les trois fichiers de references/ contiennent la règle fictive, le texte de remplacement et la décision de transmission au juriste. Remplacez-les par les règles approuvées de votre organisation, le texte exact, la version, le responsable et les critères de transmission avant de traiter un véritable NDA ou MSA. Les dix jours de l’exercice ne constituent pas une position par défaut pour d’autres accords. La procédure de revue contractuelle aide à définir le passage de relais.
Confirmez que le responsable du dossier autorise le compte et le traitement documentaire choisis. Le Skill fournit des instructions écrites. Il ne peut imposer une politique de compte, vérifier le secret professionnel, connecter un CLM ou envoyer un projet. Une personne utilisant Claude a besoin d’un éditeur approuvé qui préserve les fonctions Word existantes. Si seul le texte brut est disponible, fournissez des notes par clause pour saisir les propositions dans Word. Préservez les révisions antérieures, renvois, annexes, commentaires et définitions dans une version distincte.
Décider d’une adoption
Faites un essai sur du contenu autorisé. Relevez les questions manquées, substitutions incorrectes, propositions sans fondement, minutes de revue et éléments endommagés. Comptez les frais d’éditeur ou de modèle et le temps du juriste en comparant avec le processus actuel. L’exemple n’a mesuré aucun contrat réel, coût fournisseur, gain de temps ou résultat juridique.
Le juriste décide de chaque proposition et règle chaque question en suspens. Le responsable du dossier contrôle la diffusion. Avant le partage, vérifiez version finale, commentaires, métadonnées et destinataires selon la procédure de votre organisation.
# Inspect the fictional Word redline
This bundle demonstrates a first-pass review on a one-page English pilot agreement. No customer data, account or network access is required for the example.
1. Open `examples/incoming.docx`. Clause 2 gives the buyer three business days. Keep this original unchanged.
2. Open `examples/review-copy.docx`. In Word, choose Review and display all markup and comments. Find the deleted “three”, inserted “ten” and the REVIEW-01 comment. Find the second comment, HOLD-01, attached to the original renewal clause.
3. Save two disposable copies. Reject both revisions in one copy and confirm clause 2 reads “three business days”. Accept both in the other and confirm it reads “ten business days”. Check clause 1, its table and the full renewal clause against the original. Comments are a separate review item.
4. With Python 3 installed, run `python3 verify_sample.py` from the extracted folder. It compares the fixed pair using the standard library, without modifying either document. Success begins with `PASS: one replacement, two anchored comments`. A failed check exits with an error.
`examples/review-notes.md` records each decision. `SKILL.md` and the three references guide a reviewer adapting this pattern with an approved editor and playbook. The verifier is limited to these fixture files. The example was assembled offline and inspected structurally and visually. It was not generated by a live Claude run or tested on client agreements.
[Microsoft instructions for accepting or rejecting revisions](https://support.microsoft.com/en-us/word/accept-or-reject-tracked-changes-in-word)
---
name: contract-redline
description: Prepare an internal, clause-level review against a supplied playbook. Use the fictional Word example to verify a tracked proposal and a decision held for counsel.
---
# Contract redline review
## Inputs and responsibility
Ask for the original draft, the applicable version of a counsel-approved playbook, the selected fallback text and the named reviewer. Record the agreement version and review perspective. Work on a copy. The three files in `references/` contain training positions for a fictional pilot. Replace them before considering a real agreement.
Have the matter owner confirm that the account, client, permissions, retention and document handling are approved for this specific material before using an assistant. These instructions cannot inspect account settings, enforce confidentiality or authorize disclosure. Keep the original, revisions and review notes within the approved location.
## Decide what goes in the review copy
1. Inventory the source. Record headings, clause numbers, cross-references, definitions, tables, exhibits, existing comments and revisions. If the available document editor cannot preserve them, stop at a text-only review note. Do not label that note a tracked DOCX.
2. Map each clause to an approved rule ID and cite the exact source words. Keep wording when the rule accepts it. When the rule permits a substitution, use the approved text and identify the smallest edit.
3. Hold the original text for counsel when the rule is absent, conflicting, expired or unclear, an exhibit is missing, or defined terms and dependencies would change. Identify the decision needed. Do not generate a fallback for an uncovered clause.
4. With an approved Word-compatible editor, save a separate review copy. Add real tracked revisions and an anchored comment with the rule and rationale. An assistant without that editor delivers the review notes for manual entry. No connector, universal DOCX writer, automatic policy enforcement or sending action is included.
5. Reconcile the review copy against the original. On separate disposable copies, reject all revisions and compare with the source, then accept them and confirm each planned substitution. Inspect comments, tables, formatting, definitions and exhibits. Preserve any existing revisions separately from the new proposal.
## Fixture and expected findings
Open `examples/incoming.docx` and `examples/review-copy.docx`. The review period changes from “three” to “ten” with a native deletion and insertion. One comment cites `REVIEW-01`. Renewal receives the `HOLD-01` comment and retains its wording. The report table and clause one remain intact. See `examples/review-notes.md` for all three decisions.
Run `python3 verify_sample.py` from the extracted bundle. The script reads only the provided pair. It checks accept/reject projections, comment anchors and preservation of the other package content. It does not generate a redline for an arbitrary agreement. The sample requires no model, account or network.
## Handoff
For each clause, include the source quotation, rule/version, proposed change or hold reason and named decision owner. Keep open questions and multiple possible positions visible. Counsel checks the legal and commercial implications, existing markup and negotiation history. Obtain the required approvals before accepting changes or sharing any copy, including its comments and metadata.
"""Check the two shipped fictional DOCX files using Python's standard library."""
from copy import deepcopy
from pathlib import Path
from xml.etree import ElementTree as ET
from zipfile import ZipFile
EXAMPLES = Path(__file__).resolve().parent / "examples"
W = "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}"
REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments"
TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml"
REVIEW = "Example Buyer will review each report within three business days of receipt."
RENEWAL = "The pilot renews for another two weeks unless either party gives notice five days before expiry."
def check(condition, message):
if not condition:
raise ValueError(message)
def parts(filename):
with ZipFile(EXAMPLES / filename) as archive:
check(len(archive.namelist()) == len(set(archive.namelist())), "Duplicate package part")
return {name: archive.read(name) for name in archive.namelist()}
def xml_bytes(element):
return ET.tostring(element, encoding="utf-8")
def project(body, decision):
"""Remove comments and resolve this sample's run-level revisions in memory."""
result = deepcopy(body)
for paragraph in result.iter(W + "p"):
children = []
for node in paragraph:
if node.tag in {W + "commentRangeStart", W + "commentRangeEnd"}:
continue
if node.tag == W + "r" and node.find(W + "commentReference") is not None:
continue
if node.tag in {W + "ins", W + "del"}:
keep = node.tag == (W + "ins" if decision == "accept" else W + "del")
if keep:
for deleted in node.iter(W + "delText"):
deleted.tag = W + "t"
children.extend(list(node))
else:
children.append(node)
paragraph[:] = children
return result
def main():
original, reviewed = parts("incoming.docx"), parts("review-copy.docx")
comments_path = "word/comments.xml"
check(set(reviewed) == set(original) | {comments_path}, "Unexpected package parts")
changed = {name for name in original if original[name] != reviewed[name]}
check(changed == {"word/document.xml", "word/settings.xml", "word/_rels/document.xml.rels",
"[Content_Types].xml"}, "Unrelated package content changed")
before = ET.fromstring(original["word/document.xml"])
after = ET.fromstring(reviewed["word/document.xml"])
deletions = list(after.iter(W + "del"))
insertions = list(after.iter(W + "ins"))
check(len(deletions) == len(insertions) == 1, "Expected one deletion and one insertion")
check([t.text for t in deletions[0].iter(W + "delText")] == ["three"], "Wrong deletion")
check([t.text for t in insertions[0].iter(W + "t")] == ["ten"], "Wrong insertion")
ids = [node.get(W + "id") for node in deletions + insertions]
check(None not in ids and len(set(ids)) == 2, "Revision IDs must be distinct")
settings = ET.fromstring(reviewed["word/settings.xml"])
check(settings.find(W + "trackRevisions") is not None, "Tracking is not enabled")
comments = ET.fromstring(reviewed[comments_path])
check(len(comments) == 2, "Expected two comment bodies")
rels = ET.fromstring(reviewed["word/_rels/document.xml.rels"])
check(any(r.get("Type") == REL and r.get("Target") == "comments.xml" for r in rels),
"Missing comments relationship")
types = ET.fromstring(reviewed["[Content_Types].xml"])
check(any(t.get("PartName") == "/word/comments.xml" and t.get("ContentType") == TYPE for t in types),
"Missing comments content type")
for path, tree, addition in [
("word/settings.xml", settings, settings.find(W + "trackRevisions")),
("word/_rels/document.xml.rels", rels, next(r for r in rels if r.get("Type") == REL)),
("[Content_Types].xml", types, next(t for t in types if t.get("PartName") == "/word/comments.xml")),
]:
tree.remove(addition)
check(xml_bytes(tree) == xml_bytes(ET.fromstring(original[path])), "Unexpected change in " + path)
for cid, rule, expected in [("0", "REVIEW-01", "threeten"), ("1", "HOLD-01", RENEWAL)]:
bodies = [c for c in comments.findall(W + "comment") if c.get(W + "id") == cid]
check(len(bodies) == 1 and rule in "".join(bodies[0].itertext()), "Missing comment " + rule)
anchors = {}
for kind in ("commentRangeStart", "commentRangeEnd", "commentReference"):
matches = [n for n in after.iter(W + kind) if n.get(W + "id") == cid]
check(len(matches) == 1, "Invalid " + kind + " for " + rule)
anchors[kind] = matches[0]
paragraph = next(p for p in after.iter(W + "p") if anchors["commentRangeStart"] in p)
nodes = list(paragraph)
start, end = nodes.index(anchors["commentRangeStart"]), nodes.index(anchors["commentRangeEnd"])
check(start < end and anchors["commentReference"] in nodes[end + 1], "Misplaced comment reference")
check("".join(text for n in nodes[start + 1:end] for text in n.itertext()) == expected,
"Comment attached to unexpected text")
check(xml_bytes(project(after, "reject")) == xml_bytes(before), "Reject changed the original document body")
accepted = deepcopy(before)
text_nodes = [t for t in accepted.iter(W + "t") if t.text == "three"]
check(len(text_nodes) == 1, "Missing unique review-period token")
paragraphs = ["".join(p.itertext()) for p in before.iter(W + "p")]
check(REVIEW in paragraphs and RENEWAL in paragraphs, "Missing fixture clause")
text_nodes[0].text = "ten"
check(xml_bytes(project(after, "accept")) == xml_bytes(accepted), "Accept changed unrelated content")
print("PASS: one replacement, two anchored comments, accept/reject document bodies and preserved package parts.")
if __name__ == "__main__":
main()
# Fictional pilot deviation notes
Source is `incoming.docx`. Output is the separate `review-copy.docx`. The three rules use the exercise version dated 2026-11-02. The review perspective is Example Buyer. All decisions remain with the reviewer.
| Location | Source and decision | Evidence in the review copy |
|---|---|---|
| 1 Pilot report | REPORT-01. Keep the weekly inventory report and delivery table | No revision or comment |
| 2 Review period | REVIEW-01. Replace “three” with “ten” in the review period, leaving “business days of receipt” in place | One deletion, one insertion and one comment at the replacement |
| 3 Renewal | HOLD-01. The playbook lacks a position on automatic renewal and the five-day notice period | No revision. One comment anchored to the unchanged sentence asks counsel to decide |
The exercise leaves the renewal decision open. Counsel should also consider whether the proposed ten-business-day review period works with a two-week pilot. The redline has not been approved for negotiation or execution.
# Fictional pilot review playbook
Exercise version 2026-11-02. Perspective is Example Buyer. These positions apply only to the English pilot excerpt in the sample. The example supplies no firm's approved positions or jurisdictional conclusions.
| Rule | Match in the sample | Action |
|---|---|---|
| REPORT-01 | Clause 1 describes the inventory report, PDF format and weekly delivery | Leave the clause and table intact |
| REVIEW-01 | Clause 2 gives Example Buyer three business days to review each report | Propose the time period in the fallback file and attach a comment |
| HOLD-01 | Clause 3 automatically renews the pilot and sets a notice period | Preserve its words and request a decision from counsel |
For your own version, identify the client or matter, review perspective, agreement types, owner, approval date, version, exact allowed language and mandatory escalations. Have counsel approve the replacement before working on live material. A similar title alone does not establish a rule match.
# Fictional fallback text
Exercise version 2026-11-02. The sample uses one substitution under REVIEW-01. It demonstrates the mechanics of a tracked change. Ten business days is an invented exercise position.
Original clause 2 sentence:
> Example Buyer will review each report within three business days of receipt.
Proposed sentence:
> Example Buyer will review each report within ten business days of receipt.
Delete only “three” and insert “ten”. Preserve the surrounding sentence and its formatting. Attach the REVIEW-01 comment to the replacement. Ask counsel to check the period against the two-week pilot schedule.
REPORT-01 has no substitution. HOLD-01 has no fallback text. A real fallback library needs an approval record, scope and stable rule ID for each entry.
# Review holds
Exercise version 2026-11-02. Clause 3 has a renewal and notice mechanism. The fictional playbook supplies no accepted renewal position. Leave the whole clause unchanged and attach a HOLD-01 comment asking counsel whether to keep or revise it.
For real matters, have counsel define the escalation rules for the specific agreement. Hold a proposed edit when the clause has no applicable approved rule, the original and an exhibit conflict, an essential attachment is absent, a defined term changes meaning or existing revisions make the baseline unclear. Record the source words, reason and decision owner.
Have the matter owner confirm who may access the document and which processing environment is approved. This file is an instruction for review. It contains no technical enforcement and authorizes no service or model.