Add files using upload-large-folder tool

tasks/ip-bbb-aaa-t1-b/environment/app/contract.docx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:048eda3d993fffa4cb846d5f898aaffcc1d4f3cdd9aac29f638ae6d75eabfa64
+size 25373

tasks/ip-bbb-aaa-t1-b/environment/app/grounding/Side B Commercial Context - Digital License Agreement.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b2ac630d2ae5963035e7f6d81d9b77da36c7353422b5e61e1f0a6dbfa75638ba
+size 19026

tasks/ip-bbb-aaa-t1-b/environment/app/grounding/Side B Playbook - Digital Content License (BBB Interactive) (3) (2).docx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9cad620c9b1b048e39a9e0bab44df583a0ea181c64d9b480dd41e3216aa6188e
+size 30917

tasks/ip-bbb-aaa-t1-b/tests/baseline/contract.docx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:048eda3d993fffa4cb846d5f898aaffcc1d4f3cdd9aac29f638ae6d75eabfa64
+size 25373

tasks/ip-bbb-aaa-t1-e/environment/app/contract.docx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:048eda3d993fffa4cb846d5f898aaffcc1d4f3cdd9aac29f638ae6d75eabfa64
+size 25373

tasks/ip-bbb-aaa-t1-e/environment/app/grounding/Side B Commercial Context - Digital License Agreement.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b2ac630d2ae5963035e7f6d81d9b77da36c7353422b5e61e1f0a6dbfa75638ba
+size 19026

tasks/ip-bbb-aaa-t1-e/environment/app/grounding/Side B Playbook - Digital Content License (BBB Interactive) (3) (2).docx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9cad620c9b1b048e39a9e0bab44df583a0ea181c64d9b480dd41e3216aa6188e
+size 30917

tasks/ip-bbb-aaa-t1-e/tests/baseline/contract.docx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:048eda3d993fffa4cb846d5f898aaffcc1d4f3cdd9aac29f638ae6d75eabfa64
+size 25373

tasks/ip-bbb-aaa-t2-c/environment/app/contract.docx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8a509851d62997312e5a30944a0d346efa6832129011a4c40ad02641ddc88c54
+size 33223

tasks/ip-bbb-aaa-t2-c/environment/app/grounding/Side A Commercial Context - Digital License Agreement.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f64bdc4fb6f8fdcd9087299937d7e14c56b8b867556e01a3fe0e7cec4bfb13cc
+size 18660

tasks/ip-bbb-aaa-t2-c/environment/app/grounding/Side A Playbook - Digital Content IP License (1) (1).docx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:adc11b9b4c0cb42a522959f3e057569bc85a534156bcd57882c2af9a40ea2a70
+size 45732

tasks/ip-bbb-aaa-t2-c/tests/baseline/contract.docx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8a509851d62997312e5a30944a0d346efa6832129011a4c40ad02641ddc88c54
+size 33223

tasks/ip-bbb-aaa-t2-d/environment/app/contract.docx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dae14f7e046a004cb7df8e32b4636a3c00fcc25e2ab1f1cc2d9d7ac7d7341495
+size 37959

tasks/ip-bbb-aaa-t2-d/environment/app/grounding/Side A Commercial Context - Digital License Agreement.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f64bdc4fb6f8fdcd9087299937d7e14c56b8b867556e01a3fe0e7cec4bfb13cc
+size 18660

tasks/ip-bbb-aaa-t2-d/environment/app/grounding/Side A Playbook - Digital Content IP License (1) (1).docx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:adc11b9b4c0cb42a522959f3e057569bc85a534156bcd57882c2af9a40ea2a70
+size 45732

tasks/ip-bbb-aaa-t2-d/tests/baseline/contract.docx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dae14f7e046a004cb7df8e32b4636a3c00fcc25e2ab1f1cc2d9d7ac7d7341495
+size 37959

tasks/ip-darkside-imperial-t1-a/environment/app/contract.docx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2cbe1e8783f15ba84b2e8767d315ca07b693238ffc4da42e979921eb6cdb72ed
+size 22600

tasks/ip-darkside-imperial-t1-a/environment/app/grounding/Commercial_Context_Side_A.docx.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bb998c2912df2a8c13aac9cf55f5ea42817c4ebf50098ec095c72f1d5a096e33
+size 92533

tasks/ip-darkside-imperial-t1-a/environment/app/grounding/Darkside PLAYBOOK.docx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cb363d868049a3f07fa345e7c700eb6107aa5f48af4d140608e95041e5fc9c5c
+size 39578

tasks/ip-darkside-imperial-t1-a/tests/baseline/contract.docx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2cbe1e8783f15ba84b2e8767d315ca07b693238ffc4da42e979921eb6cdb72ed
+size 22600

tasks/ip-inventor-boardgame-t1-a/environment/app/contract.docx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5181aa56f8d3fc3c541f4a9178252c980a9a460e09374a23995eb868a84e31c0
+size 11828

tasks/ip-inventor-boardgame-t1-a/environment/app/grounding/Invention Option Agreement - Side B Commercial Context.v2.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a6a94628a57d92afaeb04515da4784bff6c97456bf8c60fb5d29e1ec806d8828
+size 18648

tasks/ip-inventor-boardgame-t1-a/tests/baseline/contract.docx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5181aa56f8d3fc3c541f4a9178252c980a9a460e09374a23995eb868a84e31c0
+size 11828

tasks/ip-sentry-calloway-t1-a/environment/app/contract.docx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:30ddc65de7e7140d2b5827cb13e628a5d526bd6134923356bee8c8a9ab204c9d
+size 26527

tasks/ip-sentry-calloway-t1-a/environment/app/grounding/Commercial Context - Side A - Sentry Aerial Systems.docx.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:03cac4199735797454e7029c4dff38402bdc3ed1acbfa720bc209f67b6bf6c0f
+size 69700

tasks/ip-sentry-calloway-t1-a/environment/app/grounding/Sentry Aerial Systems Multi-Use Contract Playbook.docx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:eb58ef595d16d5dcc1d17365b2a8dd6c46f90815ab43fccef19f696c0be5a0ab
+size 100863

tasks/ip-sentry-calloway-t1-a/tests/baseline/contract.docx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:30ddc65de7e7140d2b5827cb13e628a5d526bd6134923356bee8c8a9ab204c9d
+size 26527

tasks/ip-whithill-hartsong-t1-a/environment/Dockerfile

@@ -0,0 +1,23 @@
+FROM python:3.12-slim
+
+# Basic utilities agent installers commonly need (claude-code, codex, opencode).
+# poppler-utils provides pdftotext: the grounding documents (playbook, commercial context) are
+# shipped in their original PDF / Word form, and the agent has to read them itself.
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    ca-certificates curl git unzip poppler-utils \
+    && rm -rf /var/lib/apt/lists/*
+
+# Skill + verifier dependencies. litellm is for the verifier's judge call;
+# the docx stack is shared by the skill scripts and the verifier; pypdf is a
+# pure-Python fallback reader for the PDF grounding documents.
+RUN pip install --no-cache-dir \
+    "python-docx==1.2.0" "docx-revisions>=0.1.5" "lxml>=5.0" "litellm>=1.83" "pypdf>=5.0"
+
+# The contract-redliner skill (SKILL.md + scripts + vendored engine).
+COPY skills/ /skills/
+
+# Task documents: the contract to redline + grounding materials.
+COPY app/ /app/
+RUN python -c "import zipfile; zipfile.ZipFile('/app/contract.docx').testzip()"  # fails on an LFS pointer file
+
+WORKDIR /app

tasks/ip-whithill-hartsong-t1-a/environment/skills/contract-redliner/SKILL.md

@@ -0,0 +1,244 @@
+---
+name: contract-redliner
+description: Redline Word (.docx) contracts with native tracked changes and margin comments, the way an attorney works in Word's Review pane. Use when asked to redline, mark up, revise, or respond to a contract or other .docx legal document — every edit must be a real tracked change (insertion/deletion) with a rationale comment, applied via the bundled scripts, never by rewriting the file.
+compatibility: Requires Python 3.10+ with python-docx==1.2.0, docx-revisions, and lxml installed.
+---
+
+# Contract Redliner
+
+Redline a `.docx` contract with real Word tracked changes (`<w:ins>`/`<w:del>`)
+and threaded margin comments. The deliverable is the same file, edited in
+place, that opens cleanly in Microsoft Word's Review pane.
+
+Never edit the `.docx` by other means (unzipping it, rewriting XML, or
+regenerating the file) — that destroys tracked-change attribution. All edits
+go through the scripts below. Always pass the same `--author` string on every
+call in a session — it is the name that appears in Word's Review pane and how
+your work is attributed.
+
+## Scripts
+
+1. **Read the document:**
+
+   ```bash
+   python scripts/read_document.py CONTRACT.docx
+   ```
+
+   Prints the contract as Markdown. Every paragraph has an ID like `[p-027]`,
+   assigned in reading order for the current view and stable while you apply a
+   batch of edits from one read. The IDs are **positional**, though: adding a new
+   paragraph with `insert_paragraph_after` shifts the ID of every paragraph after
+   it on the *next* `read_document.py`. So if a later command targets a paragraph
+   by id after you've inserted one, re-run `read_document.py` first and use the
+   fresh id. Existing tracked changes are shown **inline** in the body —
+   `++inserted++` for insertions, `~~struck~~` for deletions — so you read the
+   document exactly as the reviewer will; paragraphs carrying changes/comments
+   are also flagged `{REVS,CMTS}`, and an appendix lists each existing comment
+   (`cmt-N`, with author and thread parent) and tracked change (`rev-N`, with
+   author and text). On a response turn you can anchor to text the counterparty
+   inserted — copy it without the `++…++` markers (see `references/anchors.md`).
+
+   The same script reads any other `.docx` you are given (a playbook, a deal
+   memo): the paragraph IDs it prints for those are for your reading only. For
+   a `.pdf`, use `pdftotext -layout FILE -` (or `pypdf`); both are installed.
+
+2. **Apply a batch of tracked changes:**
+
+   ```bash
+   python scripts/propose_edits.py CONTRACT.docx edits.json --author "Jane (AgentCo Legal)"
+   ```
+
+   `edits.json` is an array of edit objects (full schema and anchor rules:
+   [references/anchors.md](references/anchors.md)):
+
+   ```json
+   [
+     {
+       "op": "replace",
+       "anchor": {"paragraph_id": "p-032", "text": "thirty (30) days’ written notice"},
+       "new_text": "ten (10) business days’ written notice",
+       "comment": "We shortened the notice window because our subprocessors ship on faster cycles than 30 days."
+     },
+     {
+       "op": "delete",
+       "anchor": {"paragraph_id": "p-033", "text": "(i) will render accurate and reliable results,"},
+       "comment": "We can't warrant that AI outputs are accurate in every case — a breach claim would attach to any imperfect output."
+     }
+   ]
+   ```
+
+   Ops: `replace`, `delete`, `insert_after`, `insert_paragraph_after`
+   (`new_text` required for all but `delete`). `comment` is required on every
+   edit. Results print as JSON per edit; exit code 1 means at least one edit
+   failed.
+
+   - `insert_after` inserts `new_text` **inline**, within the anchor paragraph.
+   - `insert_paragraph_after` adds a **new standalone paragraph** (a real new,
+     fully-tracked `<w:p>`) immediately after the anchor paragraph. Use it — not
+     `insert_after` — whenever a redline must add a **new numbered section or
+     clause**; `insert_after` cannot create a new paragraph and would leave the
+     clause as a run-on inside the anchor paragraph. Fill the placeholders below
+     with the actual section number, title, and clause text your task calls for:
+
+   ```json
+   {
+     "op": "insert_paragraph_after",
+     "anchor": {"paragraph_id": "p-018", "text": "<a unique phrase ending the section this should follow>"},
+     "new_text": "<N.N> <New Section Title>. <The full text of the clause you are adding.>",
+     "comment": "<your rationale for adding this section>"
+   }
+   ```
+
+3. **If an edit fails, fix only that edit and resubmit it.** A failed anchor
+   returns `status: "anchor_failed"` with the reason — `text_not_found` (your
+   text isn't a verbatim substring of that paragraph) or `ambiguous` (it
+   matches more than once; candidates are listed). Re-read the paragraph in
+   the `read_document.py` output, tighten the anchor (add `paragraph_id`,
+   `context_before`/`context_after`, or `occurrence`), and resubmit a batch
+   containing only the failed edits — successful ones are already saved in
+   the file.
+
+   > **`propose_edits.py` applies and saves the batch the moment it runs — it is
+   > not idempotent.** Never re-run a batch that already succeeded (even if its
+   > output scrolled off or a pipe broke): re-running double-applies edits — an
+   > `insert_after`/`replace` whose new text contains its own anchor will
+   > duplicate the text and its comment — and edits that already changed a
+   > paragraph now return `text_not_found`, a misleading "everything failed"
+   > signal. After any run, re-run `read_document.py` and submit **only** the
+   > still-needed edits, anchored on the current text.
+
+4. **Standalone comments and thread replies:**
+
+   ```bash
+   # New thread on a paragraph
+   python scripts/add_comment.py CONTRACT.docx --paragraph-id p-035 \
+       --comment "Can you confirm whether any Agents are offshore?" --author "Jane (AgentCo Legal)"
+
+   # Reply to existing comment cmt-24 (use the paragraph the thread sits on)
+   python scripts/add_comment.py CONTRACT.docx --paragraph-id p-035 --reply-to 24 \
+       --comment "Agreed — we accepted this change." --author "Jane (AgentCo Legal)"
+   ```
+
+   **Comments with a `$`, quotes, or newlines: use `--comment-file`, not
+   `--comment`.** A double-quoted `--comment "…$44,000…"` is mangled by the
+   shell (bash expands `$2`), corrupting the saved comment. Write the text to a
+   file (or pipe via `-`) so it's read verbatim:
+
+   ```bash
+   printf '%s' 'The fee cap is $44,000; anything above needs written consent.' > /tmp/c.txt
+   python scripts/add_comment.py CONTRACT.docx --paragraph-id p-035 \
+       --comment-file /tmp/c.txt --author "Jane (AgentCo Legal)"
+   ```
+   (Per-edit `comment` fields inside the `propose_edits.py` JSON are already safe
+   — they never transit the shell.)
+
+4b. **Internal escalations** — flag an issue for your own side's approval instead
+   of redlining it:
+
+   ```bash
+   printf '%s' "We can't take a position on the marketplace exclusivity without sign-off." > /tmp/esc.txt
+   python scripts/add_comment.py CONTRACT.docx --paragraph-id p-041 --escalation \
+       --approvers "Talent Agent, Legal Counsel" \
+       --comment-file /tmp/esc.txt --author "Jane (AgentCo Legal)"
+   ```
+
+   `--escalation` marks the comment as an **internal** note rather than a
+   counterparty-facing one: the saved text begins `ESCALATE:` and, with
+   `--approvers`, ends `Approval required from: <roles>.` Use it when a position
+   needs sign-off before it goes to the other side — and leave the clause itself
+   unredlined unless your instructions say otherwise. Name the issue, the clause,
+   and the approver(s) in the text.
+
+   `--escalation` cannot be combined with `--reply-to`: a reply sits on a thread
+   the counterparty reads, so it isn't an internal note. Never type `ESCALATE:`
+   into the contract body or into an edit's rationale comment — the first is
+   contract text, the second is counterparty-facing.
+
+5. **Whole-section removal** (preserves downstream numbering):
+
+   ```bash
+   python scripts/mark_reserved.py CONTRACT.docx --start p-036 --end p-037 \
+       --comment "We removed this section because ..." --author "Jane (AgentCo Legal)"
+   ```
+
+   This tracked-deletes the body text of every paragraph in the range — including
+   an inline-typed section number/title if the number is part of the paragraph's
+   own text — and tracked-inserts "Reserved." into the first one. Auto-numbered
+   (list) numbering is preserved, so downstream sections don't renumber. It leaves
+   any tracked changes the counterparty already made inside the range **in place**;
+   reject or accept those separately with `propose_edits.py`.
+
+6. **Verify before finishing.** Re-run `read_document.py` and confirm the
+   appendix shows your tracked changes under your author name and your
+   comments where you expect them. The saved file is the deliverable.
+
+## Known limitation
+
+`insert_after` shows the anchor text in both the deletion and insertion halves
+of the tracked change (it is implemented as replace anchor → anchor+new text).
+This is cosmetically noisy but legally equivalent; prefer `replace` with the
+full revised phrase when inserting mid-sentence. `insert_after` also inserts
+**inline** and cannot add a new paragraph — to add a new numbered section or
+clause, use `insert_paragraph_after`.
+
+## Editing text the other side has already tracked-changed (response turns)
+
+On a response turn the document already carries the counterparty's tracked
+changes. In the read view these appear inline as `~~their deletion~~` /
+`++their insertion++`. A word or number can be **part base text and part their
+pending edit** — e.g. (illustrative figures) the read view shows `$++4++4,000`,
+meaning the base is `$4,000` and the other side inserted a `4` to propose
+`$44,000`.
+
+A single `replace`/`delete` op **cannot span across — or fully contain — one of
+their tracked-change markers**, whether an insertion (`++…++`) or a deletion
+(`~~…~~`): the anchored text mixes settled base with their unaccepted edit, which
+are different revision layers. Attempting it returns
+`runtime_error: ... across a revision boundary`; nothing is applied. This is
+expected — decide, per revision layer, and apply one op each:
+
+1. **Accept or reject their pending edit EXPLICITLY — do not just leave it.**
+   Leaving a counterparty tracked change untouched reads as "not reviewed," NOT as
+   acceptance. Each counterparty change has a stable `rev-N` id (shown in the
+   "Existing tracked changes" appendix of the read view). Resolve the ones you've
+   decided on with an `accept` / `reject` op, passing the `rev-N`:
+
+   ```bash
+   python scripts/propose_edits.py CONTRACT.docx - --author "Jane (AgentCo Legal)" <<'JSON'
+   [{"op": "accept", "revision_ids": [12], "comment": "Agreed — acceptable as drafted."}]
+   JSON
+   ```
+
+   - **accept** an insertion keeps their text as settled text; **accept** a deletion
+     finalizes it. Use `accept` when you AGREE with their change.
+   - **To REJECT or counter their change, leave a VISIBLE tracked change of your own** —
+     strike their inserted text with a `delete` op anchored exactly on it (renders
+     `~~their text~~`), or `replace` it with your own language. A bare `reject` op
+     removes their change with NO visible tracked mark of your own; prefer a visible
+     strike so your rejection is recorded as your own tracked change. (`reject` on a
+     counterparty deletion simply restores the struck text.)
+   - A counterparty **replace** is a paired strike + insertion — TWO `rev-N`; `accept`
+     BOTH together to adopt it, or strike / `replace` their inserted text visibly to reject it.
+   - `comment` is optional here. `accept`/`reject` target only the OTHER side's
+     `rev-N`; use `replace`/`delete`/`insert_after` to make YOUR OWN edits.
+2. **To COUNTER** (reject theirs and propose your own), strike their inserted text with
+   a `delete` op anchored exactly on it (a VISIBLE `~~…~~`) — or `replace` it with your
+   language — then `replace`/`insert_after` on the surrounding base text as needed.
+   Prefer striking their text visibly over a bare `reject` op, so your counter is a
+   recorded tracked change of your own.
+3. **Edit surrounding base text in its own op.** A single `replace`/`delete` op
+   **cannot span across — or fully contain — one of their tracked-change markers**
+   (`++…++` / `~~…~~`): the anchored text would mix settled base with their
+   unaccepted edit (different revision layers) → `runtime_error: ... across a
+   revision boundary`, and nothing is applied. Anchor only the base portion.
+
+Example (illustrative figures) — they proposed `$4,000` → `$44,000` (read view
+`$++4++4,000`) and you want `$8,000`: (1) `reject` the `rev-N` for their inserted
+`4`, then (2) `replace` `4,000` → `8,000`. Accepting all revisions then yields
+`$8,000`, and the redline reads cleanly as your rejection plus your counter.
+
+> Do **not** leave a counterparty change unresolved when your task is to accept,
+> reject, or counter it. Accepting-by-inaction is NOT acceptance — an unresolved
+> change reads as "not reviewed," and leaving a leftover inserted fragment next to
+> your own edit can fuse into nonsense on accept-all. Resolve every counterparty
+> change you act on.

tasks/ip-whithill-hartsong-t1-a/environment/skills/contract-redliner/references/anchors.md

@@ -0,0 +1,103 @@
+# Edit schema and anchor reference
+
+## Edit object schema (`propose_edits.py`)
+
+```json
+{
+  "op": "replace" | "delete" | "insert_after" | "insert_paragraph_after",
+  "anchor": {
+    "paragraph_id": "p-027",
+    "text": "verbatim substring of the paragraph",
+    "context_before": "optional text immediately before the anchor",
+    "context_after": "optional text immediately after the anchor",
+    "occurrence": 1
+  },
+  "new_text": "required for replace / insert_after / insert_paragraph_after",
+  "comment": "required — the rationale margin comment"
+}
+```
+
+| op | effect | new_text |
+|---|---|---|
+| `replace` | tracked-delete `anchor.text`, tracked-insert `new_text` in its place | required |
+| `delete` | tracked-delete `anchor.text` | ignored |
+| `insert_after` | tracked-insert `new_text` **inline**, immediately after `anchor.text` (same paragraph) | required |
+| `insert_paragraph_after` | add a **new standalone paragraph** (a real, fully-tracked `<w:p>`) right after the anchor paragraph — for a new numbered section/clause | required |
+
+> The `comment` (and `new_text`) here are read from the edits **JSON file**, so
+> dollar amounts / quotes / newlines are safe. Standalone comments via
+> `add_comment.py` must use **`--comment-file`** for such text — a shell
+> `--comment "…$44,000…"` is mangled by bash before the script sees it.
+
+## Anchor resolution rules
+
+- **`text` is required** and must be a verbatim substring of the target
+  paragraph's current text. Copy it from the `read_document.py` output, not
+  from memory.
+- **Always supply `paragraph_id`** (the `p-NNN` from the document view). It
+  restricts the search to one paragraph, which avoids nearly all ambiguity.
+- Matching is **normalized on both sides**, so these differences never cause a
+  mismatch: curly vs straight quotes (`’` ≡ `'`, `“”` ≡ `"`), en/em dashes vs
+  hyphens, non-breaking spaces, and runs of whitespace (any amount of
+  whitespace matches a single space).
+- Anything else must match exactly — case, punctuation, spelling.
+- **Anchor to the text as it currently reads, with prior insertions kept and
+  prior deletions removed.** On a response turn the document already contains the
+  counterparty's tracked changes; `read_document.py` shows them inline as
+  `++inserted++` and `~~struck~~`. You *can* anchor to text the counterparty
+  inserted — copy it **without** the `++…++` markers (they are not part of the
+  text). Ignore `~~struck~~` text entirely; it is already deleted and cannot be
+  anchored. Refining or striking counterparty-inserted wording (a nested edit) is
+  fully supported and shows up correctly in the reviewer's view.
+- If a `replace`/`delete` reports `runtime_error … across a revision boundary`,
+  your span straddles **or fully contains** a prior tracked change (an insertion
+  or a deletion) — narrow the anchor so it sits entirely inside (or entirely
+  outside) that inserted/deleted run. To
+  change a value the counterparty has partially edited (e.g. read view
+  `$++4++4,000`, illustrative), split into two ops: one on their pending edit (a `delete`
+  anchored on their `++inserted++` text to reject it, or leave it to accept) and
+  one on the surrounding base text. See SKILL.md → "Editing text the other side
+  has already tracked-changed."
+- If `text` appears more than once in the paragraph, disambiguate with either:
+  - `occurrence`: 1-indexed position among the matches (1 = first), or
+  - `context_before` / `context_after`: short verbatim snippets adjacent to
+    the intended match (whitespace at the boundary is forgiven).
+
+## Failure modes and fixes
+
+Every edit returns a JSON result. Statuses:
+
+| status | meaning | fix |
+|---|---|---|
+| `ok` | applied; `comment_id` is the margin comment's id | — |
+| `anchor_failed` / `text_not_found` | `text` is not a substring of that paragraph | Re-read the paragraph; copy the exact current text (it may already contain your earlier edits) |
+| `anchor_failed` / `ambiguous` | matched multiple places; `candidates` lists paragraph ids | Add `paragraph_id`, then `occurrence` or context fields |
+| `anchor_failed` / `paragraph_not_found` | bad `paragraph_id` | Use an id that appears in the current document view |
+| `runtime_error` | the engine could not apply the edit | Read `error`; usually re-anchoring on a smaller span fixes it |
+
+Two rules of thumb:
+
+1. **After any successful batch, the paragraph text has changed.** If you need
+   a second edit in the same paragraph, re-run `read_document.py` first and
+   anchor on the *current* text.
+2. **Resubmit only the failed edits.** `propose_edits.py` saves the batch the
+   moment it runs (it is **not idempotent**), so re-running a batch that already
+   succeeded double-applies each edit — and an `insert_after`/`replace` whose new
+   text contains its anchor duplicates the text. If a run's output was lost or
+   interrupted, re-read with `read_document.py` before resubmitting anything.
+
+## Choosing good anchors
+
+- Anchor on the **shortest span that is unique** within the paragraph —
+  usually 4–10 words. Whole-sentence anchors break when any word in the
+  sentence was already edited.
+- For `replace`, anchor exactly the words being changed, not the surrounding
+  sentence. The tracked change then reads as a surgical word-level edit, which
+  is what reviewers expect.
+- For `insert_after`, anchor the few words you want the insertion to follow
+  (commonly the end of a sentence including its period). It stays **inline** in
+  the anchor paragraph.
+- For `insert_paragraph_after`, anchor any text in the paragraph the new section
+  should follow (e.g. the number of the preceding section). The new clause lands
+  as its own new paragraph — use this for a new numbered section, never
+  `insert_after` (which cannot create a paragraph).

tasks/ip-whithill-hartsong-t1-a/environment/skills/contract-redliner/scripts/add_comment.py

@@ -0,0 +1,167 @@
+#!/usr/bin/env python3
+"""Add a margin comment to a .docx contract, in place.
+
+Usage:
+    # New standalone comment thread on a paragraph:
+    python add_comment.py CONTRACT.docx --paragraph-id p-014 \
+        --comment "Can you confirm the data residency requirement applies here?" \
+        --author "Jane (AgentCo Legal)"
+
+    # Threaded reply to an existing comment (cmt-N from read_document.py).
+    # --paragraph-id is the paragraph the parent comment sits on:
+    python add_comment.py CONTRACT.docx --paragraph-id p-014 --reply-to 3 \
+        --comment "Agreed — we accepted this change." \
+        --author "Jane (AgentCo Legal)"
+
+Comment text: pass EITHER --comment "..." OR --comment-file PATH (use '-' for
+stdin). Prefer --comment-file whenever the text contains a `$`, quotes, or
+newlines — dollar amounts like "$250,000" get silently mangled by the shell
+when passed as a double-quoted --comment argument (bash reads `$2` as a
+positional parameter). --comment-file reads the text verbatim, never touching
+the shell (the same reason propose_edits.py takes its edits from a JSON file).
+
+    # Internal escalation — an issue that needs your own side's approval before
+    # any position goes to the counterparty. Writes "ESCALATION: ..." for you:
+    python add_comment.py CONTRACT.docx --paragraph-id p-041 --escalation \
+        --approvers "Talent Agent, Legal Counsel" \
+        --comment-file /tmp/esc.txt --author "Jane (AgentCo Legal)"
+
+Use standalone comments only to flag an issue for discussion without making an
+edit (edits made via propose_edits.py already carry their own comment).
+Prints a JSON result with the assigned comment id.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from dataclasses import asdict
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from redline_engine.document import DocumentView  # noqa: E402
+from redline_engine.ops import add_standalone_comment  # noqa: E402
+
+DEFAULT_AUTHOR = "Counsel"
+# esc2 — the task sets this via [environment.env] so the literal token matches the instructions the
+# model was given ("ESCALATION:" for the comment-only design, "ESCALATE:" for redline-plus-comment).
+ESCALATION_PREFIX = (os.environ.get("ESCALATION_PREFIX") or "ESCALATION:").strip()
+# Either token is accepted as already-prefixed, so a model that types the other one is not
+# double-prefixed and the grader still detects it.
+_KNOWN_PREFIXES = ("ESCALATION:", "ESCALATE:")
+
+
+
+def _lock_docx(docx_path):
+    """Exclusive cross-process lock for a .docx read-modify-write. opencode can fire parallel bash
+    calls, so two of these scripts may run at once on the same file; without serialization they collide
+    (duplicate comment ids, silently clobbered edits, or a corrupted zip). Hold an flock on a sidecar
+    lock file for the whole load->save; the returned handle keeps the lock until this process exits.
+    Returns None on platforms without fcntl (e.g. Windows) rather than failing."""
+    try:
+        import fcntl
+    except ImportError:
+        return None
+    from pathlib import Path as _P
+    f = open(str(_P(str(docx_path) + ".lock")), "w")
+    fcntl.flock(f.fileno(), fcntl.LOCK_EX)
+    return f
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter
+    )
+    parser.add_argument("docx", help="path to the .docx file (edited in place)")
+    parser.add_argument("--paragraph-id", required=True, help="target paragraph, e.g. p-014")
+    parser.add_argument("--comment", default=None, help="comment text (inline)")
+    parser.add_argument(
+        "--comment-file",
+        default=None,
+        help="path to a file with the comment text, or '-' for stdin. Prefer this "
+        "for text with $, quotes, or newlines (avoids shell mangling).",
+    )
+    parser.add_argument(
+        "--reply-to",
+        type=int,
+        default=None,
+        help="existing comment id N (from cmt-N) to reply to instead of starting a new thread",
+    )
+    parser.add_argument(
+        "--escalation",
+        action="store_true",
+        help="mark this comment as an INTERNAL escalation to your own side: the saved text is prefixed "
+        "'ESCALATION:'. Use it for an issue that needs your side's approval before any position goes "
+        "to the counterparty, and leave the clause itself unredlined. Cannot be combined with "
+        "--reply-to.",
+    )
+    parser.add_argument(
+        "--approvers",
+        default=None,
+        help="comma-separated approver ROLES this escalation needs (e.g. \"Talent Agent, Legal "
+        "Counsel\"), appended as 'Approval required from: ...'. Only valid with --escalation.",
+    )
+    parser.add_argument("--author", default=DEFAULT_AUTHOR, help="comment author name")
+    args = parser.parse_args()
+
+    # Exactly one of --comment / --comment-file. --comment-file (or stdin) reads
+    # the text verbatim so dollar amounts / quotes / newlines never hit the shell.
+    if (args.comment is None) == (args.comment_file is None):
+        print("error: pass exactly one of --comment or --comment-file", file=sys.stderr)
+        return 2
+    if args.comment_file is not None:
+        comment_text = sys.stdin.read() if args.comment_file == "-" else Path(args.comment_file).read_text()
+    else:
+        comment_text = args.comment
+
+    if args.approvers and not args.escalation:
+        print("error: --approvers is only valid with --escalation", file=sys.stderr)
+        return 2
+    if args.escalation and args.reply_to is not None:
+        print(
+            "error: --escalation cannot be combined with --reply-to — an escalation is a standalone "
+            "INTERNAL note, and a reply sits on a thread the counterparty reads. Post the escalation "
+            "as its own comment on the paragraph the issue lives in.",
+            file=sys.stderr,
+        )
+        return 2
+    if args.escalation:
+        # The tool owns the prefix so the grader's detection is exact on the sanctioned path.
+        # Idempotent: an author who already typed the prefix doesn't get it twice.
+        body = " ".join(comment_text.split())
+        if not any(body.upper().startswith(t) for t in _KNOWN_PREFIXES):
+            body = f"{ESCALATION_PREFIX} {body}"
+        if args.approvers:
+            roles = ", ".join(x.strip() for x in args.approvers.split(",") if x.strip())
+            if roles and roles.lower() not in body.lower():
+                body = f"{body.rstrip('.')}. Approval required from: {roles}."
+        comment_text = body
+
+    path = Path(args.docx)
+    if not path.exists():
+        print(f"error: file not found: {path}", file=sys.stderr)
+        return 1
+
+    _docx_lock = _lock_docx(path)  # noqa: F841 (held until process exit; serializes concurrent writers)
+    view = DocumentView.load(path)
+    res = add_standalone_comment(
+        view,
+        paragraph_id=args.paragraph_id,
+        comment=comment_text,
+        author=args.author,
+        reply_to_comment_id=args.reply_to,
+    )
+    view._docx.save(str(path))  # noqa: SLF001
+
+    out = {k: v for k, v in asdict(res).items() if v not in (None, [], "")}
+    if args.escalation:
+        out["escalation"] = True  # echo it back so the caller can verify the prefix landed
+    print(json.dumps(out, indent=2))
+    return 0 if out.get("status") == "ok" else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

tasks/ip-whithill-hartsong-t1-a/environment/skills/contract-redliner/scripts/docx_revisions-0.1.5.dist-info/INSTALLER

@@ -0,0 +1 @@
+uv

tasks/ip-whithill-hartsong-t1-a/environment/skills/contract-redliner/scripts/docx_revisions-0.1.5.dist-info/METADATA

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: docx-revisions
+Version: 0.1.5
+Summary: Track changes (revisions) support for python-docx: read, write and manipulate <w:ins> and <w:del> elements
+Project-URL: Homepage, https://github.com/balalofernandez/docx-revisions
+Project-URL: Documentation, https://balalofernandez.github.io/docx-revisions
+Project-URL: Repository, https://github.com/balalofernandez/docx-revisions
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: lxml>=4.9.0
+Requires-Dist: python-docx>=1.1.0
+Provides-Extra: dev
+Requires-Dist: mkdocs-material>=9.0; extra == 'dev'
+Requires-Dist: mkdocstrings[python]>=0.24; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: ruff>=0.1; extra == 'dev'
+Provides-Extra: examples
+Requires-Dist: pydantic-ai>=1.51.0; extra == 'examples'
+Description-Content-Type: text/markdown
+
+# Python Tracked Changes Library - docx-revisions
+
+<p align="center">
+  <a href="https://balalofernandez.github.io/docx-revisions" target="_blank"><img src="https://img.shields.io/badge/Docs-0066FF" alt="Documentation"></a>
+  <a href="https://github.com/balalofernandez/docx-revisions/actions/workflows/tests.yml"><img src="https://github.com/balalofernandez/docx-revisions/actions/workflows/tests.yml/badge.svg" alt="Tests"></a>
+  <a href="https://github.com/balalofernandez/docx-revisions/actions/workflows/docs.yml"><img src="https://github.com/balalofernandez/docx-revisions/actions/workflows/docs.yml/badge.svg" alt="Docs"></a>
+  <a href="https://pypi.org/project/docx-revisions" target="_blank"><img src="https://img.shields.io/pypi/v/docx-revisions" alt="PyPI"></a>
+  <!-- <a href="https://pepy.tech/projects/docx-revisions"><img src="https://static.pepy.tech/badge/docx-revisions" alt="PyPI Downloads"></a> -->
+</p>
+
+**Read and write track changes in Word documents (.docx) with Python.** docx-revisions extends [python-docx](https://python-docx.readthedocs.io/) to support **document revision tracking**, **change tracking**, and **OOXML** revision markup (insertions `<w:ins>` and deletions `<w:del>`) so you can programmatically accept text, list revisions with author and date, and apply insertions, deletions, or replacements with full revision metadata.
+
+Use it for **Microsoft Word**-compatible revision tracking: parse DOCX files with track changes on, get accepted (clean) text, enumerate revisions per paragraph, or write new revisions (insert/delete/replace) that show up as track changes in Word.
+
+## Installation
+
+```bash
+pip install docx-revisions
+```
+
+## Quick Start
+
+### Check out our examples!
+
+Navigate to the [examples directory](https://github.com/balalofernandez/docx-revisions/tree/main/examples) to see code samples.
+
+### Read tracked changes
+
+```python
+from docx_revisions import RevisionDocument
+
+rdoc = RevisionDocument("tracked_changes.docx")
+for para in rdoc.paragraphs:
+    if para.has_track_changes:
+        for change in para.track_changes:
+            print(f"{type(change).__name__}: '{change.text}' by {change.author}")
+        print(f"Accepted: {para.accepted_text}")
+        print(f"Original: {para.original_text}")
+```
+
+### Accept or reject all changes
+
+```python
+from docx_revisions import RevisionDocument
+
+rdoc = RevisionDocument("tracked_changes.docx")
+rdoc.accept_all()   # or rdoc.reject_all()
+rdoc.save("clean.docx")
+```
+
+### Find and replace with tracking
+
+```python
+from docx_revisions import RevisionDocument
+
+rdoc = RevisionDocument("contract.docx")
+count = rdoc.find_and_replace_tracked("Acme Corp", "NewCo Inc", author="Legal")
+print(f"Replaced {count} occurrences")
+rdoc.save("contract_revised.docx")
+```
+
+### Add tracked insertions and deletions
+
+```python
+from docx_revisions import RevisionParagraph
+
+rp = RevisionParagraph.from_paragraph(paragraph)
+rp.add_tracked_insertion("new text", author="Editor")
+rp.add_tracked_deletion(start=5, end=10, author="Editor")
+```

tasks/ip-whithill-hartsong-t1-a/environment/skills/contract-redliner/scripts/docx_revisions-0.1.5.dist-info/RECORD

@@ -0,0 +1,13 @@
+docx_revisions-0.1.5.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2
+docx_revisions-0.1.5.dist-info/METADATA,sha256=qBV0lPAWaw6EFfaOrMklkJLtw5Twi8TMqC0u8r2TcZc,3883
+docx_revisions-0.1.5.dist-info/RECORD,,
+docx_revisions-0.1.5.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+docx_revisions-0.1.5.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+docx_revisions-0.1.5.dist-info/licenses/LICENSE,sha256=zErhD-66QHXGynsQ5HN0AzCOC9ONeSKE9A06H03e9G0,1072
+docx_revisions/__init__.py,sha256=jA7SGOrJ4abzHPaJkNKPE_nsyBb4PyOgSt_mVHbJAaE,719
+docx_revisions/_helpers.py,sha256=pua1RXAbQtrHhU2syOc_JUSc2BnLc6TrMXlSmw9fzvw,3148
+docx_revisions/document.py,sha256=qySX5AIUgWsBz2lhhCJB2N6B-WMu8nMWmeF3ju-fKIM,8451
+docx_revisions/oxml.py,sha256=2zniaSSzzFZG6JGpWOWiW0neBWcvKlRRFG_A2uRbwmc,5465
+docx_revisions/paragraph.py,sha256=jg5J91rhS2J3KPMvwupEEGf79-3V9H8d_0Igkt9WSBo,23137
+docx_revisions/revision.py,sha256=EQydJTLToPFztE2R_yF-tduv1FRD3xuT0fyOuZXWIYQ,7997
+docx_revisions/run.py,sha256=Mt0yzROai3U_rCLGzFOuHvc455CCzT6r6yJVtSjo6fY,4629

tasks/ip-whithill-hartsong-t1-a/environment/skills/contract-redliner/scripts/docx_revisions-0.1.5.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

tasks/ip-whithill-hartsong-t1-a/environment/skills/contract-redliner/scripts/docx_revisions-0.1.5.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 balalofernandez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tasks/ip-whithill-hartsong-t1-a/environment/skills/contract-redliner/scripts/docx_revisions/VENDORED.md

@@ -0,0 +1,27 @@
+# Vendored dependency
+
+`docx_revisions/` (+ the sibling `docx_revisions-0.1.5.dist-info/`) is vendored
+from PyPI **docx-revisions==0.1.5** (MIT, https://github.com/balalofernandez/docx-revisions),
+with **one local fix** (see below).
+
+## Local fix — end-inclusive end-offset resolution (`paragraph.py`)
+
+`replace_tracked_at` and `add_tracked_deletion` resolved the *exclusive* `end`
+offset with `_find_unit_at_offset`, which is inclusive semantics. When a span
+ended exactly on a run/revision boundary (e.g. an edit that sits entirely inside
+one prior `w:ins` but ends at that insertion's boundary), `end` resolved to the
+*next* unit and the call raised a false **"Cannot apply tracked … across a
+revision boundary"** — blocking in-place edits of counterparty-inserted text.
+Both call sites now resolve `end` end-inclusively (`_find_unit_at_offset(end-1)`
+then `+1`). Search the file for `[vendored local fix` to find the two spots.
+This copy is model-facing only; the grader never imports `docx_revisions`.
+
+Why: the contract-redliner scripts (`propose_edits.py`, `mark_reserved.py`,
+`add_comment.py` reply path) import `RevisionParagraph` from `docx_revisions`,
+but the image's PyPI copy lacks the local fix above and nothing can be installed at
+runtime (no network egress). It is vendored
+here (a sibling of `redline_engine/`, resolved via `sys.path[0]`) so the tools
+work with zero code change. The `.dist-info` is included so `importlib.metadata.
+version("docx-revisions")` in `__init__.py` resolves; `__init__.py` also guards
+that call as belt-and-suspenders. Runtime deps (`python-docx`, `lxml`) are
+already installed in the image.

tasks/ip-whithill-hartsong-t1-a/environment/skills/contract-redliner/scripts/docx_revisions/__init__.py

@@ -0,0 +1,30 @@
+"""docx-revisions: Track changes support for python-docx."""
+
+from importlib.metadata import version
+
+from docx_revisions.document import RevisionDocument
+from docx_revisions.oxml import register_revision_elements
+from docx_revisions.paragraph import RevisionParagraph
+from docx_revisions.revision import TrackedChange, TrackedDeletion, TrackedInsertion
+from docx_revisions.run import RevisionRun
+
+# Register OXML element classes so lxml produces typed instances
+# for w:ins, w:del, w:delText, etc.
+register_revision_elements()
+
+# Vendored into this skill (see VENDORED.md). The .dist-info is shipped alongside
+# so this resolves, but guard it so a missing-metadata edge never crashes import
+# of the model's redlining tools (that ModuleNotFoundError-style crash is exactly
+# the env defect this vendoring fixes).
+try:
+    __version__ = version("docx-revisions")
+except Exception:
+    __version__ = "0.1.5"
+__all__ = [
+    "RevisionDocument",
+    "RevisionParagraph",
+    "RevisionRun",
+    "TrackedChange",
+    "TrackedDeletion",
+    "TrackedInsertion",
+]

tasks/ip-whithill-hartsong-t1-a/environment/skills/contract-redliner/scripts/docx_revisions/_helpers.py

@@ -0,0 +1,98 @@
+"""Shared XML element builders for revision tracking.
+
+Centralises the repeated patterns for creating ``w:r``, ``w:del``, ``w:ins``
+elements and the ``before / del / ins / after`` splice used by both
+``RevisionParagraph`` and ``RevisionRun``.
+"""
+
+from __future__ import annotations
+
+import contextlib
+from typing import Callable
+
+from docx.oxml.ns import qn
+from docx.oxml.parser import OxmlElement
+from lxml import etree
+
+
+def revision_attrs(rev_id: int, author: str, now: str) -> dict[str, str]:
+    """Build the standard ``{w:id, w:author, w:date}`` attribute dict."""
+    return {qn("w:id"): str(rev_id), qn("w:author"): author, qn("w:date"): now}
+
+
+def make_text_run(text: str) -> OxmlElement:
+    """Create a ``<w:r><w:t>text</w:t></w:r>`` element with space preservation."""
+    r = OxmlElement("w:r")
+    t = OxmlElement("w:t")
+    t.text = text
+    if text.startswith(" ") or text.endswith(" "):
+        t.set(qn("xml:space"), "preserve")
+    r.append(t)
+    return r
+
+
+def make_del_element(deleted_text: str, author: str, rev_id: int, now: str) -> OxmlElement:
+    """Create a ``<w:del><w:r><w:delText>text</w:delText></w:r></w:del>`` element."""
+    del_elem = OxmlElement("w:del", attrs=revision_attrs(rev_id, author, now))
+    del_r = OxmlElement("w:r")
+    del_text_elem = OxmlElement("w:delText")
+    del_text_elem.text = deleted_text
+    del_r.append(del_text_elem)
+    del_elem.append(del_r)
+    return del_elem
+
+
+def make_ins_element(insert_text: str, author: str, rev_id: int, now: str) -> OxmlElement:
+    """Create a ``<w:ins><w:r><w:t>text</w:t></w:r></w:ins>`` element."""
+    ins_elem = OxmlElement("w:ins", attrs=revision_attrs(rev_id, author, now))
+    ins_r = OxmlElement("w:r")
+    ins_t = OxmlElement("w:t")
+    ins_t.text = insert_text
+    ins_r.append(ins_t)
+    ins_elem.append(ins_r)
+    return ins_elem
+
+
+def splice_tracked_replace(
+    parent: etree._Element,
+    index: int,
+    before_text: str | None,
+    deleted_text: str,
+    insert_text: str,
+    after_text: str | None,
+    author: str,
+    next_id_fn: Callable[[], int],
+    now: str,
+) -> int:
+    """Insert the before-run / w:del / w:ins / after-run sequence into *parent* at *index*.
+
+    Returns:
+        The number of elements inserted.
+    """
+    insert_idx = index
+    if before_text:
+        parent.insert(insert_idx, make_text_run(before_text))
+        insert_idx += 1
+
+    parent.insert(insert_idx, make_del_element(deleted_text, author, next_id_fn(), now))
+    insert_idx += 1
+
+    parent.insert(insert_idx, make_ins_element(insert_text, author, next_id_fn(), now))
+    insert_idx += 1
+
+    if after_text:
+        parent.insert(insert_idx, make_text_run(after_text))
+        insert_idx += 1
+
+    return insert_idx - index
+
+
+def next_revision_id(element: etree._Element) -> int:
+    """Generate the next unique revision ID by scanning the document tree from *element*."""
+    max_id = 0
+    for ins_or_del in element.xpath("//w:ins | //w:del"):
+        id_val = ins_or_del.get(qn("w:id"))
+        if id_val is not None:
+            with contextlib.suppress(ValueError):
+                max_id = max(max_id, int(id_val))
+    return max_id + 1

tasks/ip-whithill-hartsong-t1-a/environment/skills/contract-redliner/scripts/docx_revisions/document.py

@@ -0,0 +1,229 @@
+"""RevisionDocument — the main entry point for working with tracked changes.
+
+Opens a ``.docx`` file (or wraps an existing ``Document``) and exposes
+paragraphs as ``RevisionParagraph`` objects, plus document-level operations
+for accepting, rejecting, and performing find-and-replace with tracking.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import IO, Iterator, List
+
+from docx import Document as _new_document
+from docx.document import Document as _DocumentClass
+from docx.table import Table as _Table
+
+from docx_revisions.paragraph import IndexMode, RevisionParagraph
+from docx_revisions.revision import TrackedChange
+
+
+class RevisionDocument:
+    """Entry point for reading and writing tracked changes in a docx file.
+
+    Example:
+        ```python
+        from docx_revisions import RevisionDocument
+
+        rdoc = RevisionDocument("contract.docx")
+        for para in rdoc.paragraphs:
+            if para.has_track_changes:
+                print(para.accepted_text)
+
+        rdoc.accept_all()
+        rdoc.save("contract_clean.docx")
+        ```
+    """
+
+    def __init__(self, path_or_doc: str | Path | IO[bytes] | _DocumentClass | None = None):
+        """Open a docx file or wrap an existing ``Document``.
+
+        Args:
+            path_or_doc: A file path, file-like object, or an existing
+                ``Document`` instance.  Pass ``None`` to create a new
+                blank document.
+        """
+        if isinstance(path_or_doc, _DocumentClass):
+            self._document = path_or_doc
+        else:
+            self._document = _new_document(path_or_doc)
+
+    @property
+    def document(self) -> _DocumentClass:
+        """The underlying python-docx ``Document`` object."""
+        return self._document
+
+    @property
+    def paragraphs(self) -> List[RevisionParagraph]:
+        """All body paragraphs as ``RevisionParagraph`` objects.
+
+        Only paragraphs in the document body are returned. Paragraphs inside
+        tables are excluded. Use :attr:`all_paragraphs` to iterate over every
+        paragraph including those nested in tables.
+        """
+        return [RevisionParagraph.from_paragraph(p) for p in self._document.paragraphs]
+
+    @property
+    def all_paragraphs(self) -> List[RevisionParagraph]:
+        """Every paragraph in the document, including those inside tables.
+
+        Walks the document body and recurses into all tables (including
+        nested tables within cells).
+
+        Example:
+            ```python
+            rdoc = RevisionDocument("contract.docx")
+            for para in rdoc.all_paragraphs:
+                if para.has_track_changes:
+                    print(para.accepted_text)
+            ```
+        """
+        return list(self._iter_all_paragraphs())
+
+    def _iter_all_paragraphs(self) -> Iterator[RevisionParagraph]:
+        """Yield every ``RevisionParagraph`` in the body and all tables.
+
+        Recurses into nested tables via ``cell.tables``.
+        """
+        for p in self._document.paragraphs:
+            yield RevisionParagraph.from_paragraph(p)
+        for table in self._document.tables:
+            yield from self._iter_table_paragraphs(table)
+
+    def _iter_table_paragraphs(self, table: _Table) -> Iterator[RevisionParagraph]:
+        """Yield every ``RevisionParagraph`` inside *table* recursively."""
+        for row in table.rows:
+            for cell in row.cells:
+                for p in cell.paragraphs:
+                    yield RevisionParagraph.from_paragraph(p)
+                for nested in cell.tables:
+                    yield from self._iter_table_paragraphs(nested)
+
+    @property
+    def track_changes(self) -> List[TrackedChange]:
+        """All tracked changes across the document body and tables."""
+        changes: List[TrackedChange] = []
+        for para in self._iter_all_paragraphs():
+            changes.extend(para.track_changes)
+        return changes
+
+    def accept_all(self) -> None:
+        """Accept every tracked change in the document.
+
+        Insertions are kept (wrapper removed), deletions are removed entirely.
+        Tracked changes inside tables (including nested tables) are processed.
+        Loops until no tracked changes remain so that nested revisions (which
+        can arise from ``replace_tracked(index_mode="accepted")``) are fully
+        resolved.
+        """
+        for para in self._iter_all_paragraphs():
+            while para.track_changes:
+                for change in list(para.track_changes):
+                    change.accept()
+
+    def reject_all(self) -> None:
+        """Reject every tracked change in the document.
+
+        Insertions are removed entirely, deletions are kept (wrapper removed,
+        ``w:delText`` converted back to ``w:t``). Tracked changes inside
+        tables (including nested tables) are processed. Loops until no tracked
+        changes remain.
+        """
+        for para in self._iter_all_paragraphs():
+            while para.track_changes:
+                for change in list(para.track_changes):
+                    change.reject()
+
+    def find_and_replace_tracked(
+        self,
+        search_text: str,
+        replace_text: str,
+        author: str = "",
+        comment: str | None = None,
+        index_mode: IndexMode = "text",
+    ) -> int:
+        """Find and replace across the whole document with track changes.
+
+        Searches all paragraphs in the document body and tables (including
+        nested tables).
+
+        Args:
+            search_text: Text to find.
+            replace_text: Replacement text.
+            author: Author name for the revisions.
+            comment: Optional comment text (requires python-docx comment
+                support).
+            index_mode: Which text view to search against per paragraph.  See
+                :meth:`RevisionParagraph.replace_tracked` — ``"text"`` (default),
+                ``"accepted"``, or ``"original"``.
+
+        Returns:
+            Total number of replacements made.
+
+        Example:
+            ```python
+            rdoc = RevisionDocument("doc.docx")
+            # Replace against the accepted view so matches inside prior
+            # tracked insertions are also found.
+            count = rdoc.find_and_replace_tracked(
+                "Acme Corp", "NewCo Inc", author="Legal", index_mode="accepted"
+            )
+            rdoc.save("doc_revised.docx")
+            ```
+        """
+        total_count = 0
+        for para in self._iter_all_paragraphs():
+            total_count += para.replace_tracked(
+                search_text, replace_text, author=author, comment=comment, index_mode=index_mode
+            )
+        return total_count
+
+    def save(self, path_or_stream: str | Path | IO[bytes]) -> None:
+        """Save the document to a path or file-like object.
+
+        Args:
+            path_or_stream: Destination file path (``str`` or ``Path``) or a
+                writable binary file-like object (anything with a ``write``
+                method, such as ``io.BytesIO``).
+
+        Raises:
+            TypeError: If *path_or_stream* is neither a path nor a writable
+                binary stream.
+            ValueError: If *path_or_stream* is an empty string, or is a text-
+                mode file object.
+
+        Example:
+            ```python
+            import io
+            from docx_revisions import RevisionDocument
+
+            rdoc = RevisionDocument("contract.docx")
+            rdoc.accept_all()
+
+            buffer = io.BytesIO()
+            rdoc.save(buffer)
+            buffer.seek(0)
+            data = buffer.read()
+            ```
+        """
+        if isinstance(path_or_stream, str | Path):
+            path_str = str(path_or_stream)
+            if not path_str:
+                raise ValueError("save() path must not be empty")
+            self._document.save(path_str)
+            return
+
+        write = getattr(path_or_stream, "write", None)
+        if not callable(write):
+            raise TypeError(
+                f"save() expects a str, Path, or writable binary file-like object; got {type(path_or_stream).__name__}"
+            )
+
+        mode = getattr(path_or_stream, "mode", None)
+        if isinstance(mode, str) and "b" not in mode:
+            raise ValueError(
+                f"save() requires a binary-mode stream; got mode={mode!r}. "
+                "Open the file with mode='wb' or use io.BytesIO()."
+            )
+
+        self._document.save(path_or_stream)

tasks/ip-whithill-hartsong-t1-a/environment/skills/contract-redliner/scripts/docx_revisions/oxml.py

@@ -0,0 +1,154 @@
+"""Custom element classes for revision tracking (tracked changes).
+
+Registers OXML element classes so that lxml produces typed elements
+(e.g. ``CT_RunTrackChange``) instead of generic ``BaseOxmlElement``
+when parsing ``w:ins``, ``w:del``, and related revision elements.
+"""
+
+from __future__ import annotations
+
+import datetime as dt
+from typing import TYPE_CHECKING, List
+
+from docx.oxml.ns import qn
+from docx.oxml.simpletypes import ST_String, XsdInt
+from docx.oxml.text.run import CT_Text
+from docx.oxml.xmlchemy import BaseOxmlElement, OptionalAttribute, RequiredAttribute, ZeroOrMore, ZeroOrOne
+
+if TYPE_CHECKING:
+    from docx.oxml.table import CT_Tbl
+    from docx.oxml.text.paragraph import CT_P
+    from docx.oxml.text.run import CT_R
+
+
+class CT_TrackChange(BaseOxmlElement):
+    """Base class for tracked change elements.
+
+    This serves as the base for ``w:ins``, ``w:del``, and other revision
+    tracking elements.  Provides common attributes: ``w:id``, ``w:author``,
+    and ``w:date``.
+    """
+
+    id: int = RequiredAttribute("w:id", XsdInt)  # pyright: ignore[reportAssignmentType]
+    author: str = RequiredAttribute("w:author", ST_String)  # pyright: ignore[reportAssignmentType]
+    date: str | None = OptionalAttribute("w:date", ST_String)  # pyright: ignore[reportAssignmentType]
+
+    @property
+    def date_value(self) -> dt.datetime | None:
+        """The ``w:date`` attribute as a datetime object, or None if not set."""
+        date_str = self.date
+        if date_str is None:
+            return None
+        try:
+            return dt.datetime.fromisoformat(date_str.replace("Z", "+00:00"))
+        except ValueError:
+            return None
+
+    @date_value.setter
+    def date_value(self, value: dt.datetime | None):
+        """Set the ``w:date`` attribute from a datetime object."""
+        if value is None:
+            date_qn = qn("w:date")
+            if date_qn in self.attrib:  # pyright: ignore[reportUnknownMemberType]
+                del self.attrib[date_qn]  # pyright: ignore[reportUnknownMemberType]
+        else:
+            self.date = value.strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+class CT_RunTrackChange(CT_TrackChange):
+    """``w:ins`` or ``w:del`` element containing run-level content.
+
+    Used for tracking insertions and deletions at the run level within a
+    paragraph, or at the block level containing paragraphs and tables.
+    """
+
+    p_lst: List[CT_P]
+    tbl_lst: List[CT_Tbl]
+    r_lst: List[CT_R]
+
+    p = ZeroOrMore("w:p")
+    tbl = ZeroOrMore("w:tbl")
+    r = ZeroOrMore("w:r")
+
+    @property
+    def inner_content_elements(self) -> List[CT_P | CT_Tbl]:
+        """All ``w:p`` and ``w:tbl`` elements in this tracked change, in document order."""
+        return self.xpath("./w:p | ./w:tbl")
+
+    @property
+    def run_content_elements(self) -> List[CT_R]:
+        """All ``w:r`` elements in this tracked change, in document order."""
+        return self.xpath("./w:r")
+
+
+class CT_RPrChange(CT_TrackChange):
+    """``w:rPrChange`` element, tracking changes to run properties.
+
+    Contains the previous run properties before the change was made.
+    """
+
+    rPr: BaseOxmlElement | None = ZeroOrOne("w:rPr")  # pyright: ignore[reportAssignmentType]
+
+
+class CT_PPrChange(CT_TrackChange):
+    """``w:pPrChange`` element, tracking changes to paragraph properties.
+
+    Contains the previous paragraph properties before the change was made.
+    """
+
+    pPr: BaseOxmlElement | None = ZeroOrOne("w:pPr")  # pyright: ignore[reportAssignmentType]
+
+
+class CT_SectPrChange(CT_TrackChange):
+    """``w:sectPrChange`` element, tracking changes to section properties.
+
+    Contains the previous section properties before the change was made.
+    """
+
+    sectPr: BaseOxmlElement | None = ZeroOrOne("w:sectPr")  # pyright: ignore[reportAssignmentType]
+
+
+class CT_TblPrChange(CT_TrackChange):
+    """``w:tblPrChange`` element, tracking changes to table properties.
+
+    Contains the previous table properties before the change was made.
+    """
+
+    tblPr: BaseOxmlElement | None = ZeroOrOne("w:tblPr")  # pyright: ignore[reportAssignmentType]
+
+
+class CT_TcPrChange(CT_TrackChange):
+    """``w:tcPrChange`` element, tracking changes to table cell properties.
+
+    Contains the previous cell properties before the change was made.
+    """
+
+    tcPr: BaseOxmlElement | None = ZeroOrOne("w:tcPr")  # pyright: ignore[reportAssignmentType]
+
+
+class CT_TrPrChange(CT_TrackChange):
+    """``w:trPrChange`` element, tracking changes to table row properties.
+
+    Contains the previous row properties before the change was made.
+    """
+
+    trPr: BaseOxmlElement | None = ZeroOrOne("w:trPr")  # pyright: ignore[reportAssignmentType]
+
+
+def register_revision_elements() -> None:
+    """Register all revision-related OXML element classes.
+
+    Must be called once (typically at package import time) so that lxml
+    produces typed element instances when parsing revision markup.
+    """
+    from docx.oxml.parser import register_element_cls
+
+    register_element_cls("w:ins", CT_RunTrackChange)
+    register_element_cls("w:del", CT_RunTrackChange)
+    register_element_cls("w:delText", CT_Text)
+    register_element_cls("w:rPrChange", CT_RPrChange)
+    register_element_cls("w:pPrChange", CT_PPrChange)
+    register_element_cls("w:sectPrChange", CT_SectPrChange)
+    register_element_cls("w:tblPrChange", CT_TblPrChange)
+    register_element_cls("w:tcPrChange", CT_TcPrChange)
+    register_element_cls("w:trPrChange", CT_TrPrChange)

tasks/ip-whithill-hartsong-t1-a/environment/skills/contract-redliner/scripts/docx_revisions/paragraph.py

@@ -0,0 +1,654 @@
+"""RevisionParagraph — a ``Paragraph`` subclass with track-change support.
+
+Wraps an existing ``Paragraph`` (sharing the same XML element) and adds
+methods for reading, creating, accepting, and rejecting tracked insertions
+and deletions.
+"""
+
+from __future__ import annotations
+
+import datetime as dt
+from typing import TYPE_CHECKING, Iterator, List, Literal
+
+from docx.oxml.ns import qn
+from docx.oxml.parser import OxmlElement
+from docx.text.hyperlink import Hyperlink
+from docx.text.paragraph import Paragraph
+from docx.text.run import Run
+from lxml import etree
+
+from docx_revisions._helpers import (
+    make_del_element,
+    make_text_run,
+    next_revision_id,
+    revision_attrs,
+    splice_tracked_replace,
+)
+from docx_revisions.revision import TrackedChange, TrackedDeletion, TrackedInsertion
+
+if TYPE_CHECKING:
+    from docx.styles.style import CharacterStyle
+
+IndexMode = Literal["text", "accepted", "original"]
+
+_REVISION_TAGS = (qn("w:ins"), qn("w:del"), qn("w:moveFrom"), qn("w:moveTo"))
+
+
+def _assert_no_interleaved_revision(parent, first_el, last_el, what: str) -> None:
+    """[vendored local fix — see VENDORED.md] Raise if a revision wrapper sits
+    physically between the first and last spanned unit in *parent*.
+
+    The unit-parent guard alone misses this: ``_get_editable_units`` skips ``w:del``
+    (and, in ``text`` mode, any run nested inside a ``w:ins``/``w:del``), so a span
+    ``base…<w:del>…base`` enumerates two top-level runs that share the ``w:p`` parent
+    and passes the guard — but the removal loop then leaves the interleaved ``w:del``,
+    which the splice relocates, silently reordering the reject-all base text (a
+    script-only run then trips the grader's content-fidelity gate and scores 0).
+    Rejecting here converts that into the actionable revision-boundary error the
+    caller already recovers from by narrowing. A span entirely inside one ``w:ins``
+    has that ``w:ins`` as its parent, whose children are plain runs, so this never
+    false-fires on the supported in-insertion edit.
+    """
+    sibs = list(parent)
+    try:
+        i0 = sibs.index(first_el)
+        i1 = sibs.index(last_el)
+    except ValueError:
+        return
+    if i1 < i0:
+        i0, i1 = i1, i0
+    for k in range(i0, i1 + 1):
+        if sibs[k].tag in _REVISION_TAGS:
+            raise ValueError(
+                f"Cannot apply tracked {what} across a revision boundary; "
+                "operate on a narrower span entirely inside or outside a prior revision."
+            )
+
+
+class RevisionParagraph(Paragraph):
+    """A ``Paragraph`` subclass that adds track-change support.
+
+    Create from an existing ``Paragraph`` with ``from_paragraph()`` — the
+    two objects share the same underlying XML element so mutations via either
+    reference are visible to both.
+
+    Example:
+        ```python
+        from docx import Document
+        from docx_revisions import RevisionParagraph
+
+        doc = Document("example.docx")
+        for para in doc.paragraphs:
+            rp = RevisionParagraph.from_paragraph(para)
+            if rp.has_track_changes:
+                print(f"Insertions: {len(rp.insertions)}")
+                print(f"Deletions:  {len(rp.deletions)}")
+        ```
+    """
+
+    @classmethod
+    def from_paragraph(cls, para: Paragraph) -> RevisionParagraph:
+        """Create a ``RevisionParagraph`` that shares *para*'s XML element.
+
+        Args:
+            para: An existing ``Paragraph`` object.
+
+        Returns:
+            A ``RevisionParagraph`` wrapping the same ``<w:p>`` element.
+        """
+        return cls(para._p, para._parent)
+
+    # ------------------------------------------------------------------
+    # Read-only properties
+    # ------------------------------------------------------------------
+
+    @property
+    def has_track_changes(self) -> bool:
+        """True if this paragraph contains any ``w:ins`` or ``w:del`` children."""
+        return bool(self._p.xpath("./w:ins | ./w:del"))
+
+    @property
+    def insertions(self) -> List[TrackedInsertion]:
+        """All tracked insertions in this paragraph, in document order."""
+        return [
+            TrackedInsertion(e, self)  # pyright: ignore[reportArgumentType]
+            for e in self._p.xpath("./w:ins")
+        ]
+
+    @property
+    def deletions(self) -> List[TrackedDeletion]:
+        """All tracked deletions in this paragraph, in document order."""
+        return [
+            TrackedDeletion(e, self)  # pyright: ignore[reportArgumentType]
+            for e in self._p.xpath("./w:del")
+        ]
+
+    @property
+    def track_changes(self) -> List[TrackedChange]:
+        """All tracked changes (insertions and deletions) in document order."""
+        changes: List[TrackedChange] = []
+        for e in self._p.xpath("./w:ins | ./w:del"):
+            tag = e.tag  # pyright: ignore[reportUnknownMemberType]
+            if tag == qn("w:ins"):
+                changes.append(TrackedInsertion(e, self))  # pyright: ignore[reportArgumentType]
+            elif tag == qn("w:del"):
+                changes.append(TrackedDeletion(e, self))  # pyright: ignore[reportArgumentType]
+        return changes
+
+    def _text_view(self, *, accept_changes: bool) -> str:
+        """Return paragraph text with changes either accepted or rejected.
+
+        Args:
+            accept_changes: If True, include insertions and skip deletions
+                (accepted view).  If False, include deletions and skip
+                insertions (original/rejected view).
+        """
+        include_tag = qn("w:ins") if accept_changes else qn("w:del")
+        skip_tag = qn("w:del") if accept_changes else qn("w:ins")
+
+        def walk(element: etree._Element) -> str:
+            parts: List[str] = []
+            for child in element.xpath("./w:r | ./w:ins | ./w:del"):
+                tag = child.tag
+                if tag == qn("w:r"):
+                    for t in child.xpath("./w:t | ./w:delText"):
+                        parts.append(t.text or "")
+                elif tag == include_tag:
+                    parts.append(walk(child))
+                elif tag == skip_tag:
+                    continue
+            return "".join(parts)
+
+        return walk(self._p)
+
+    @property
+    def accepted_text(self) -> str:
+        """Text of this paragraph with all changes accepted.
+
+        Insertions are kept, deletions are removed.
+        """
+        return self._text_view(accept_changes=True)
+
+    @property
+    def original_text(self) -> str:
+        """Text of this paragraph with all changes rejected.
+
+        Deletions are kept, insertions are removed.
+        """
+        return self._text_view(accept_changes=False)
+
+    # ------------------------------------------------------------------
+    # Iteration
+    # ------------------------------------------------------------------
+
+    def iter_inner_content(  # type: ignore[override]
+        self, include_revisions: bool = False
+    ) -> Iterator[Run | Hyperlink | TrackedInsertion | TrackedDeletion]:
+        """Generate runs, hyperlinks, and optionally revisions in document order.
+
+        Args:
+            include_revisions: If True, also yields ``TrackedInsertion`` and
+                ``TrackedDeletion`` objects for run-level tracked changes.
+                Defaults to False for backward compatibility.
+
+        Yields:
+            ``Run``, ``Hyperlink``, ``TrackedInsertion``, or ``TrackedDeletion``
+            objects in document order.
+        """
+        if include_revisions:
+            elements = self._p.xpath("./w:r | ./w:hyperlink | ./w:ins | ./w:del")
+        else:
+            elements = self._p.xpath("./w:r | ./w:hyperlink")
+
+        for element in elements:
+            tag = element.tag  # pyright: ignore[reportUnknownMemberType]
+            if tag == qn("w:r"):
+                yield Run(element, self)
+            elif tag == qn("w:hyperlink"):
+                yield Hyperlink(element, self)  # pyright: ignore[reportArgumentType]
+            elif tag == qn("w:ins"):
+                yield TrackedInsertion(element, self)  # pyright: ignore[reportArgumentType]
+            elif tag == qn("w:del"):
+                yield TrackedDeletion(element, self)  # pyright: ignore[reportArgumentType]
+
+    # ------------------------------------------------------------------
+    # Write operations
+    # ------------------------------------------------------------------
+
+    def add_tracked_insertion(
+        self,
+        text: str | None = None,
+        style: str | CharacterStyle | None = None,
+        author: str = "",
+        revision_id: int | None = None,
+    ) -> TrackedInsertion:
+        """Append a tracked insertion containing a run with the specified text.
+
+        The run is wrapped in a ``w:ins`` element, marking it as inserted
+        content when track changes is enabled.
+
+        Args:
+            text: Text to add to the run.
+            style: Character style to apply to the run.
+            author: Author name for the revision.  Defaults to empty string.
+            revision_id: Unique ID for this revision.  Auto-generated if not
+                provided.
+
+        Returns:
+            A ``TrackedInsertion`` wrapping the new ``w:ins`` element.
+
+        Example:
+            ```python
+            rp = RevisionParagraph.from_paragraph(paragraph)
+            tracked = rp.add_tracked_insertion("new text", author="Editor")
+            print(tracked.text)
+            ```
+        """
+        if revision_id is None:
+            revision_id = self._next_revision_id()
+
+        ins = OxmlElement(
+            "w:ins",
+            attrs=revision_attrs(revision_id, author, dt.datetime.now(dt.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")),
+        )
+
+        r = OxmlElement("w:r")
+        ins.append(r)
+        self._p.append(ins)  # pyright: ignore[reportUnknownMemberType]
+
+        tracked_insertion = TrackedInsertion(ins, self)  # pyright: ignore[reportArgumentType]
+        if text:
+            for run in tracked_insertion.runs:
+                run.text = text
+        if style:
+            for run in tracked_insertion.runs:
+                run.style = style
+
+        return tracked_insertion
+
+    def add_tracked_deletion(
+        self, start: int, end: int, author: str = "", revision_id: int | None = None, index_mode: IndexMode = "text"
+    ) -> TrackedDeletion:
+        """Wrap existing text at *[start, end)* in a ``w:del`` element.
+
+        The text remains in the document but is marked as deleted.  The
+        corresponding ``w:t`` elements are converted to ``w:delText``.
+
+        Args:
+            start: Starting character offset (0-based, inclusive).
+            end: Ending character offset (0-based, exclusive).
+            author: Author name for the revision.
+            revision_id: Unique ID for this revision.  Auto-generated if not
+                provided.
+            index_mode: Which text view the offsets index into:
+                ``"text"`` (default, raw ``paragraph.text`` ignoring prior
+                revisions), ``"accepted"`` (``paragraph.accepted_text``, with
+                prior insertions kept and deletions skipped), or
+                ``"original"`` (``paragraph.original_text``, with prior
+                deletions kept and insertions skipped).
+
+        Returns:
+            A ``TrackedDeletion`` wrapping the new ``w:del`` element.
+
+        Raises:
+            ValueError: If offsets are invalid.
+
+        Example:
+            ```python
+            # Delete characters from the accepted (post-revision) view
+            rp.add_tracked_deletion(0, 5, author="Editor", index_mode="accepted")
+            ```
+        """
+        view_text = self._view_text(index_mode)
+        if start < 0 or end > len(view_text) or start >= end:
+            raise ValueError(f"Invalid offsets: start={start}, end={end} for text of length {len(view_text)}")
+
+        if revision_id is None:
+            revision_id = self._next_revision_id()
+
+        units = self._get_editable_units(index_mode)
+        if not units:
+            raise ValueError("Paragraph has no runs")
+        boundaries = self._unit_boundaries(units)
+
+        start_unit_idx, start_offset = self._find_unit_at_offset(boundaries, start)
+        end_unit_idx, end_offset = self._find_unit_at_offset(boundaries, end)
+        # [vendored local fix — see VENDORED.md] Resolve the EXCLUSIVE end offset
+        # end-inclusively so a span ending exactly on a unit boundary stays in the
+        # preceding unit instead of falsely crossing into the next revision.
+        if end > start:
+            _eu, _eo = self._find_unit_at_offset(boundaries, end - 1)
+            end_unit_idx, end_offset = _eu, _eo + 1
+
+        # ALL units in the [start, end] span must share the same parent for a
+        # clean single-parent splice. This holds when the span is entirely in
+        # top-level w:r runs, or entirely inside one w:ins / w:del wrapper.
+        # [vendored local fix — see VENDORED.md] Checking only the FIRST and LAST
+        # unit's parent let a span that *contains* a revision in the middle pass
+        # the guard: the removal loop then skips the middle unit (different parent)
+        # while deleted_text still included its chars → silent OOXML corruption
+        # (counterparty-inserted digits duplicated into the base text). Require
+        # every spanned unit to share the parent so the boundary case raises
+        # cleanly (the caller narrows the anchor) instead of corrupting the doc.
+        start_parent = units[start_unit_idx].getparent()
+        if start_parent is None or any(
+            units[i].getparent() is not start_parent
+            for i in range(start_unit_idx, end_unit_idx + 1)
+        ):
+            raise ValueError(
+                "Cannot apply tracked deletion across a revision boundary; "
+                "operate on a narrower span entirely inside or outside a prior revision."
+            )
+        parent = start_parent
+        _assert_no_interleaved_revision(parent, units[start_unit_idx], units[end_unit_idx], "deletion")
+
+        now = dt.datetime.now(dt.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+        def _r_text(r: etree._Element) -> str:
+            parts = []
+            for child in r.xpath("./w:t | ./w:delText"):
+                parts.append(child.text or "")
+            return "".join(parts)
+
+        # Collect the deleted text
+        deleted_text_parts: List[str] = []
+        if start_unit_idx == end_unit_idx:
+            deleted_text_parts.append(_r_text(units[start_unit_idx])[start_offset:end_offset])
+        else:
+            deleted_text_parts.append(_r_text(units[start_unit_idx])[start_offset:])
+            for i in range(start_unit_idx + 1, end_unit_idx):
+                deleted_text_parts.append(_r_text(units[i]))
+            deleted_text_parts.append(_r_text(units[end_unit_idx])[:end_offset])
+        deleted_text = "".join(deleted_text_parts)
+
+        start_r = units[start_unit_idx]
+        before_text = _r_text(start_r)[:start_offset]
+        after_text = _r_text(units[end_unit_idx])[end_offset:]
+
+        index = list(parent).index(start_r)
+        for i in range(start_unit_idx, end_unit_idx + 1):
+            run_elem = units[i]
+            if run_elem.getparent() is parent:
+                parent.remove(run_elem)
+
+        insert_idx = index
+
+        if before_text:
+            parent.insert(insert_idx, make_text_run(before_text))
+            insert_idx += 1
+
+        del_elem = make_del_element(deleted_text, author, revision_id, now)
+        parent.insert(insert_idx, del_elem)
+        insert_idx += 1
+
+        if after_text:
+            parent.insert(insert_idx, make_text_run(after_text))
+
+        return TrackedDeletion(del_elem, self)  # pyright: ignore[reportArgumentType]
+
+    def replace_tracked(
+        self,
+        search_text: str,
+        replace_text: str,
+        author: str = "",
+        comment: str | None = None,
+        index_mode: IndexMode = "text",
+    ) -> int:
+        """Replace all occurrences of *search_text* with *replace_text* using track changes.
+
+        Each replacement creates a tracked deletion of *search_text* and a
+        tracked insertion of *replace_text*.  Matches text across run
+        boundaries (handles OOXML run splitting).
+
+        Args:
+            search_text: Text to find and replace.
+            replace_text: Text to insert in place of *search_text*.
+            author: Author name for the revision.
+            comment: Optional comment text (requires python-docx comment
+                support).
+            index_mode: Which text view to search against:
+                ``"text"`` (default, raw ``paragraph.text``),
+                ``"accepted"`` (``paragraph.accepted_text``, includes prior
+                insertions, skips prior deletions), or ``"original"``
+                (``paragraph.original_text``, includes prior deletions, skips
+                prior insertions).
+
+        Returns:
+            The number of replacements made.
+
+        Example:
+            ```python
+            # Default: search raw run text
+            rp.replace_tracked("old", "new", author="Editor")
+
+            # Search the accepted view — matches land inside prior w:ins blocks
+            rp.replace_tracked(
+                "old", "new", author="Editor", index_mode="accepted"
+            )
+            ```
+        """
+        count = 0
+        full_text = self._view_text(index_mode)
+        search_len = len(search_text)
+
+        # Find all match positions in the concatenated text.
+        # Process right-to-left so earlier offsets stay valid after each splice.
+        positions: list[int] = []
+        start = 0
+        while True:
+            idx = full_text.find(search_text, start)
+            if idx == -1:
+                break
+            positions.append(idx)
+            start = idx + search_len
+
+        # Apply replacements right-to-left to preserve offsets.
+        for pos in reversed(positions):
+            self.replace_tracked_at(
+                pos, pos + search_len, replace_text, author=author, comment=comment, index_mode=index_mode
+            )
+            count += 1
+
+        return count
+
+    def replace_tracked_at(
+        self,
+        start: int,
+        end: int,
+        replace_text: str,
+        author: str = "",
+        comment: str | None = None,
+        index_mode: IndexMode = "text",
+    ) -> None:
+        """Replace text at character offsets *[start, end)* using track changes.
+
+        Creates a tracked deletion of the text at positions ``[start, end)``
+        and a tracked insertion of *replace_text* at that position.
+
+        Args:
+            start: Starting character offset (0-based, inclusive).
+            end: Ending character offset (0-based, exclusive).
+            replace_text: Text to insert in place of the deleted text.
+            author: Author name for the revision.
+            comment: Optional comment text (requires python-docx comment
+                support).
+            index_mode: Which text view the offsets index into.  See
+                :meth:`replace_tracked`.
+
+        Raises:
+            ValueError: If *start* or *end* are out of bounds or *start* >= *end*.
+
+        Example:
+            ```python
+            # Offsets are interpreted against accepted_text
+            rp.replace_tracked_at(
+                0, 5, "Hi", author="Editor", index_mode="accepted"
+            )
+            ```
+        """
+        view_text = self._view_text(index_mode)
+        if start < 0 or end > len(view_text) or start >= end:
+            raise ValueError(f"Invalid offsets: start={start}, end={end} for text of length {len(view_text)}")
+
+        units = self._get_editable_units(index_mode)
+        if not units:
+            raise ValueError("Paragraph has no runs")
+        boundaries = self._unit_boundaries(units)
+
+        start_unit_idx, start_offset_in_unit = self._find_unit_at_offset(boundaries, start)
+        end_unit_idx, end_offset_in_unit = self._find_unit_at_offset(boundaries, end)
+        # [vendored local fix — see VENDORED.md] Resolve the EXCLUSIVE end offset
+        # end-inclusively: an end that lands exactly on a unit boundary belongs to
+        # the preceding unit (its last char), not the next unit's start. Without
+        # this, a [start, end) span sitting entirely inside one prior revision but
+        # ending on that revision's boundary is falsely reported as crossing a
+        # revision boundary (blocking in-place edits of counterparty-inserted text).
+        if end > start:
+            _eu, _eo = self._find_unit_at_offset(boundaries, end - 1)
+            end_unit_idx, end_offset_in_unit = _eu, _eo + 1
+
+        # [vendored local fix — see VENDORED.md] Require EVERY unit in the span to
+        # share one parent, not just the first & last: a span that fully contains a
+        # counterparty revision (base…w:ins…base) has matching first/last parents
+        # but a middle unit under the w:ins, which the removal loop below skips
+        # while deleted_text still copies its chars → silent base-text corruption.
+        # Raising here converts that into the actionable revision-boundary error
+        # (the caller narrows the anchor) instead of a corrupted deliverable.
+        start_parent = units[start_unit_idx].getparent()
+        if start_parent is None or any(
+            units[i].getparent() is not start_parent
+            for i in range(start_unit_idx, end_unit_idx + 1)
+        ):
+            raise ValueError(
+                "Cannot apply tracked replacement across a revision boundary; "
+                "operate on a narrower span entirely inside or outside a prior revision."
+            )
+        parent = start_parent
+        _assert_no_interleaved_revision(parent, units[start_unit_idx], units[end_unit_idx], "replacement")
+
+        now = dt.datetime.now(dt.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+        def _r_text(r: etree._Element) -> str:
+            parts = []
+            for child in r.xpath("./w:t | ./w:delText"):
+                parts.append(child.text or "")
+            return "".join(parts)
+
+        if start_unit_idx == end_unit_idx:
+            r = units[start_unit_idx]
+            text = _r_text(r)
+            before_text = text[:start_offset_in_unit] or None
+            deleted_text = text[start_offset_in_unit:end_offset_in_unit]
+            after_text = text[end_offset_in_unit:] or None
+            first_r = r
+        else:
+            first_r = units[start_unit_idx]
+            start_text = _r_text(first_r)
+            before_text = start_text[:start_offset_in_unit] or None
+            deleted_from_start = start_text[start_offset_in_unit:]
+
+            end_r = units[end_unit_idx]
+            end_text = _r_text(end_r)
+            deleted_from_end = end_text[:end_offset_in_unit]
+            after_text = end_text[end_offset_in_unit:] or None
+
+            middle_deleted = "".join(_r_text(units[i]) for i in range(start_unit_idx + 1, end_unit_idx))
+            deleted_text = deleted_from_start + middle_deleted + deleted_from_end
+
+        index = list(parent).index(first_r)
+
+        # Remove spanned runs (only if they share the parent, which the check above guarantees)
+        for i in range(start_unit_idx, end_unit_idx + 1):
+            run_elem = units[i]
+            if run_elem.getparent() is parent:
+                parent.remove(run_elem)
+
+        splice_tracked_replace(
+            parent, index, before_text, deleted_text, replace_text, after_text, author, self._next_revision_id, now
+        )
+
+    # ------------------------------------------------------------------
+    # Private helpers
+    # ------------------------------------------------------------------
+
+    def _next_revision_id(self) -> int:
+        """Generate the next unique revision ID for this document."""
+        return next_revision_id(self._p)
+
+    def _view_text(self, index_mode: IndexMode) -> str:
+        """Return the paragraph text for the chosen index mode."""
+        if index_mode == "text":
+            return self.text
+        if index_mode == "accepted":
+            return self.accepted_text
+        if index_mode == "original":
+            return self.original_text
+        raise ValueError(f"Unknown index_mode: {index_mode!r}")
+
+    def _get_editable_units(self, index_mode: IndexMode) -> List[etree._Element]:
+        """Return the ordered list of ``w:r`` elements that make up *index_mode*'s view.
+
+        - ``"text"``: only top-level ``w:r`` children.
+        - ``"accepted"``: walk ``w:r`` children, recurse into ``w:ins``
+          (prior insertions visible), skip ``w:del``.
+        - ``"original"``: walk ``w:r`` children, recurse into ``w:del``
+          (prior deletions visible), skip ``w:ins``.
+        """
+        if index_mode == "text":
+            return list(self._p.xpath("./w:r"))
+
+        if index_mode == "accepted":
+            recurse_tag = qn("w:ins")
+            skip_tag = qn("w:del")
+        elif index_mode == "original":
+            recurse_tag = qn("w:del")
+            skip_tag = qn("w:ins")
+        else:
+            raise ValueError(f"Unknown index_mode: {index_mode!r}")
+
+        units: List[etree._Element] = []
+
+        def walk(element: etree._Element) -> None:
+            for child in element.xpath("./w:r | ./w:ins | ./w:del"):
+                tag = child.tag
+                if tag == qn("w:r"):
+                    units.append(child)
+                elif tag == recurse_tag:
+                    walk(child)
+                elif tag == skip_tag:
+                    continue
+
+        walk(self._p)
+        return units
+
+    @staticmethod
+    def _unit_boundaries(units: List[etree._Element]) -> List[tuple[int, int, int]]:
+        """Return ``(unit_index, start_offset, end_offset)`` for each unit."""
+        boundaries: List[tuple[int, int, int]] = []
+        offset = 0
+        for i, r in enumerate(units):
+            # Sum text from both w:t and w:delText direct children
+            run_len = 0
+            for child in r.xpath("./w:t | ./w:delText"):
+                run_len += len(child.text or "")
+            boundaries.append((i, offset, offset + run_len))
+            offset += run_len
+        return boundaries
+
+    @staticmethod
+    def _find_unit_at_offset(boundaries: List[tuple[int, int, int]], offset: int) -> tuple[int, int]:
+        """Find which unit contains *offset* and the offset within that unit."""
+        for unit_idx, unit_start, unit_end in boundaries:
+            if unit_start <= offset < unit_end or (offset == unit_end and unit_idx == len(boundaries) - 1):
+                return unit_idx, offset - unit_start
+        last_idx, last_start, _ = boundaries[-1]
+        return last_idx, offset - last_start
+
+    # Back-compat aliases (used by older external code or tests that may import them)
+    def _get_run_boundaries(self) -> List[tuple[int, int, int]]:
+        """Deprecated: use :meth:`_get_editable_units` + :meth:`_unit_boundaries`."""
+        return self._unit_boundaries(self._get_editable_units("text"))
+
+    def _find_run_at_offset(self, boundaries: List[tuple[int, int, int]], offset: int) -> tuple[int, int]:
+        """Deprecated: use :meth:`_find_unit_at_offset`."""
+        return self._find_unit_at_offset(boundaries, offset)

tasks/ip-whithill-hartsong-t1-a/environment/skills/contract-redliner/scripts/docx_revisions/revision.py

@@ -0,0 +1,254 @@
+"""TrackedInsertion and TrackedDeletion classes for accessing and manipulating
+tracked changes (revisions) in a Word document.
+
+These proxy objects wrap ``w:ins`` and ``w:del`` OXML elements and provide a
+high-level API for reading metadata, extracting text, and accepting or
+rejecting individual revisions.
+"""
+
+from __future__ import annotations
+
+import datetime as dt
+from typing import TYPE_CHECKING, Iterator, List
+
+from docx.oxml.ns import qn
+from docx.shared import Parented
+
+if TYPE_CHECKING:
+    import docx.types as t
+    from docx.table import Table
+    from docx.text.paragraph import Paragraph
+    from docx.text.run import Run
+
+    from docx_revisions.oxml import CT_RunTrackChange
+
+
+class TrackedChange(Parented):
+    """Base class for tracked change proxy objects.
+
+    Provides common functionality for both insertions and deletions.
+    """
+
+    def __init__(self, element: CT_RunTrackChange, parent: t.ProvidesStoryPart):
+        super().__init__(parent)
+        self._element = element
+
+    @property
+    def author(self) -> str:
+        """The author who made this change."""
+        return self._element.author
+
+    @author.setter
+    def author(self, value: str):
+        self._element.author = value
+
+    @property
+    def date(self) -> dt.datetime | None:
+        """The date/time when this change was made, or None if not recorded."""
+        return self._element.date_value
+
+    @date.setter
+    def date(self, value: dt.datetime | None):
+        self._element.date_value = value
+
+    @property
+    def revision_id(self) -> int:
+        """The unique identifier for this revision."""
+        return self._element.id
+
+    @revision_id.setter
+    def revision_id(self, value: int):
+        self._element.id = value
+
+    # ------------------------------------------------------------------
+    # Shared content-access properties
+    # ------------------------------------------------------------------
+
+    @property
+    def is_block_level(self) -> bool:
+        """True if this change contains block-level content (paragraphs/tables)."""
+        return bool(self._element.inner_content_elements)
+
+    @property
+    def is_run_level(self) -> bool:
+        """True if this change contains run-level content."""
+        return bool(self._element.run_content_elements)
+
+    def iter_inner_content(self) -> Iterator[Paragraph | Table]:
+        """Generate Paragraph or Table objects for block-level content."""
+        from docx.table import Table
+        from docx.text.paragraph import Paragraph
+
+        for element in self._element.inner_content_elements:
+            tag = element.tag  # pyright: ignore[reportUnknownMemberType]
+            if tag == qn("w:p"):
+                yield Paragraph(element, self._parent)  # pyright: ignore[reportArgumentType]
+            elif tag == qn("w:tbl"):
+                yield Table(element, self._parent)  # pyright: ignore[reportArgumentType]
+
+    def iter_runs(self) -> Iterator[Run]:
+        """Generate Run objects for run-level content."""
+        from docx.text.run import Run
+
+        for r in self._element.run_content_elements:
+            yield Run(r, self._parent)  # pyright: ignore[reportArgumentType]
+
+    @property
+    def paragraphs(self) -> List[Paragraph]:
+        """List of paragraphs in this change (for block-level changes)."""
+        from docx.text.paragraph import Paragraph
+
+        return [
+            Paragraph(p, self._parent)  # pyright: ignore[reportArgumentType]
+            for p in self._element.p_lst
+        ]
+
+    @property
+    def runs(self) -> List[Run]:
+        """List of runs in this change (for run-level changes)."""
+        from docx.text.run import Run
+
+        return [
+            Run(r, self._parent)  # pyright: ignore[reportArgumentType]
+            for r in self._element.r_lst
+        ]
+
+    def accept(self) -> None:
+        """Accept this tracked change.
+
+        For an insertion, this removes the revision wrapper, keeping the content.
+        For a deletion, this removes both the wrapper and the content.
+        """
+        raise NotImplementedError("Subclasses must implement accept()")
+
+    def reject(self) -> None:
+        """Reject this tracked change.
+
+        For an insertion, this removes both the wrapper and the content.
+        For a deletion, this removes the revision wrapper, keeping the content.
+        """
+        raise NotImplementedError("Subclasses must implement reject()")
+
+
+class TrackedInsertion(TrackedChange):
+    """Proxy object wrapping a ``w:ins`` element.
+
+    Represents content that was inserted while track changes was enabled.
+    The inserted content can be paragraphs, tables, or runs depending on
+    context.
+    """
+
+    @property
+    def text(self) -> str:
+        """The text content of this insertion.
+
+        For block-level insertions, returns concatenated text of all paragraphs.
+        For run-level insertions, returns concatenated text of all runs.
+        """
+        if self.is_block_level:
+            return "\n".join(p.text for p in self.paragraphs)
+        return "".join(r.text for r in self.runs)
+
+    def accept(self) -> None:
+        """Accept this insertion, keeping the content but removing the revision wrapper."""
+        parent = self._element.getparent()
+        if parent is None:
+            return
+
+        index = list(parent).index(self._element)
+        for child in reversed(list(self._element)):
+            parent.insert(index, child)
+
+        parent.remove(self._element)
+
+    def reject(self) -> None:
+        """Reject this insertion, removing both the content and the revision wrapper."""
+        parent = self._element.getparent()
+        if parent is not None:
+            _rescue_comment_markers(self._element, parent, list(parent).index(self._element))
+            parent.remove(self._element)
+
+
+def _rescue_comment_markers(element, parent, index: int) -> int:
+    """Before removing ``element`` (an accepted deletion or rejected insertion), relocate any
+    comment-range markers it contains — ``w:commentRangeStart``/``End`` and any run holding a
+    ``w:commentReference`` — up to ``parent`` at ``index``, so removing the span does not orphan a
+    comment range (leaving an unterminated range that renders with a document-spanning anchor)."""
+    marker_tags = (qn("w:commentRangeStart"), qn("w:commentRangeEnd"))
+    rescued = []
+    for m in list(element.iter()):
+        if m is element:
+            continue
+        if m.tag in marker_tags:
+            rescued.append(m)
+        elif m.tag == qn("w:r") and m.find(qn("w:commentReference")) is not None:
+            rescued.append(m)
+    for m in rescued:
+        mp = m.getparent()
+        if mp is not None:
+            mp.remove(m)
+        parent.insert(index, m)
+        index += 1
+    return index
+
+
+class TrackedDeletion(TrackedChange):
+    """Proxy object wrapping a ``w:del`` element.
+
+    Represents content that was deleted while track changes was enabled.
+    The deleted content is still present in the document but marked as
+    deleted.
+    """
+
+    @property
+    def text(self) -> str:
+        """The text content of this deletion.
+
+        For block-level deletions, returns concatenated text of all paragraphs.
+        For run-level deletions, concatenates text from ``w:delText`` elements
+        found via xpath, since ``Run.text`` only reads ``w:t``.
+        """
+        if self.is_block_level:
+            return "\n".join(p.text for p in self.paragraphs)
+        # w:del runs use w:delText instead of w:t, so we need xpath
+        del_texts = self._element.xpath(".//w:delText")
+        if del_texts:
+            return "".join(t.text or "" for t in del_texts)
+        # Fallback: try normal run text (for cases where w:t is still used)
+        return "".join(r.text for r in self.runs)
+
+    def accept(self) -> None:
+        """Accept this deletion, removing both the content and the revision wrapper."""
+        parent = self._element.getparent()
+        if parent is not None:
+            _rescue_comment_markers(self._element, parent, list(parent).index(self._element))
+            parent.remove(self._element)
+
+    def reject(self) -> None:
+        """Reject this deletion, keeping the content but removing the revision wrapper.
+
+        Also converts ``w:delText`` elements back to ``w:t`` so the text
+        becomes visible again.
+        """
+        parent = self._element.getparent()
+        if parent is None:
+            return
+
+        # Convert w:delText back to w:t before unwrapping
+        for del_text in self._element.xpath(".//w:delText"):
+            from docx.oxml.parser import OxmlElement
+
+            t_elem = OxmlElement("w:t")
+            t_elem.text = del_text.text
+            space_val = del_text.get(qn("xml:space"))
+            if space_val:
+                t_elem.set(qn("xml:space"), space_val)
+            del_text_parent = del_text.getparent()
+            if del_text_parent is not None:
+                del_text_parent.replace(del_text, t_elem)
+
+        index = list(parent).index(self._element)
+        for child in reversed(list(self._element)):
+            parent.insert(index, child)
+
+        parent.remove(self._element)

tasks/ip-whithill-hartsong-t1-a/environment/skills/contract-redliner/scripts/docx_revisions/run.py

@@ -0,0 +1,129 @@
+"""RevisionRun — a ``Run`` subclass with track-change support.
+
+Wraps an existing ``Run`` (sharing the same XML element) and adds methods
+for creating tracked deletions and offset-based replacements.
+"""
+
+from __future__ import annotations
+
+import datetime as dt
+
+from docx.oxml.ns import qn
+from docx.oxml.parser import OxmlElement
+from docx.text.run import Run
+
+from docx_revisions._helpers import next_revision_id, revision_attrs, splice_tracked_replace
+from docx_revisions.revision import TrackedDeletion
+
+
+class RevisionRun(Run):
+    """A ``Run`` subclass that adds track-change support.
+
+    Create from an existing ``Run`` with ``from_run()`` — the two objects
+    share the same underlying XML element.
+
+    Example:
+        ```python
+        from docx_revisions import RevisionRun
+
+        run = paragraph.runs[0]
+        rr = RevisionRun.from_run(run)
+        tracked = rr.delete_tracked(author="Editor")
+        ```
+    """
+
+    @classmethod
+    def from_run(cls, run: Run) -> RevisionRun:
+        """Create a ``RevisionRun`` that shares *run*'s XML element.
+
+        Args:
+            run: An existing ``Run`` object.
+
+        Returns:
+            A ``RevisionRun`` wrapping the same ``<w:r>`` element.
+        """
+        return cls(run._r, run._parent)
+
+    def delete_tracked(self, author: str = "", revision_id: int | None = None) -> TrackedDeletion:
+        """Mark this run as deleted with track changes.
+
+        Instead of removing the run, it is wrapped in a ``w:del`` element to
+        mark it as deleted content.  The run remains in the document but is
+        displayed as deleted text (e.g., with strikethrough).  The ``w:t``
+        elements are converted to ``w:delText``.
+
+        Args:
+            author: Author name for the revision.
+            revision_id: Unique ID for this revision.  Auto-generated if not
+                provided.
+
+        Returns:
+            A ``TrackedDeletion`` wrapping the ``w:del`` element.
+
+        Raises:
+            ValueError: If the run has no parent element.
+        """
+        if revision_id is None:
+            revision_id = self._next_revision_id()
+
+        parent = self._r.getparent()
+        if parent is None:
+            raise ValueError("Run has no parent element")
+
+        del_elem = OxmlElement(
+            "w:del",
+            attrs=revision_attrs(revision_id, author, dt.datetime.now(dt.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")),
+        )
+
+        for t_elem in self._r.findall(qn("w:t")):
+            delText = OxmlElement("w:delText")
+            delText.text = t_elem.text
+            if t_elem.get(qn("xml:space")) == "preserve":
+                delText.set(qn("xml:space"), "preserve")
+            t_elem.getparent().replace(t_elem, delText)  # pyright: ignore[reportOptionalMemberAccess]
+
+        index = list(parent).index(self._r)
+        parent.insert(index, del_elem)
+        del_elem.append(self._r)
+
+        return TrackedDeletion(del_elem, self._parent)  # pyright: ignore[reportArgumentType]
+
+    def replace_tracked_at(self, start: int, end: int, replace_text: str, author: str = "") -> None:
+        """Replace text at character offsets *[start, end)* using track changes.
+
+        Creates a tracked deletion of the text at positions ``[start, end)``
+        and a tracked insertion of *replace_text* at that position.
+
+        Args:
+            start: Starting character offset (0-based, inclusive).
+            end: Ending character offset (0-based, exclusive).
+            replace_text: Text to insert in place of the deleted text.
+            author: Author name for the revision.
+
+        Raises:
+            ValueError: If *start* or *end* are out of bounds or *start* >= *end*.
+        """
+        text = self.text
+        if start < 0 or end > len(text) or start >= end:
+            raise ValueError(f"Invalid offsets: start={start}, end={end} for text of length {len(text)}")
+
+        now = dt.datetime.now(dt.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+        before_text = text[:start] or None
+        deleted_text = text[start:end]
+        after_text = text[end:] or None
+
+        r_elem = self._r
+        parent = r_elem.getparent()
+        if parent is None:
+            raise ValueError("Run has no parent element")
+
+        index = list(parent).index(r_elem)
+        parent.remove(r_elem)
+
+        splice_tracked_replace(
+            parent, index, before_text, deleted_text, replace_text, after_text, author, self._next_revision_id, now
+        )
+
+    def _next_revision_id(self) -> int:
+        """Generate the next unique revision ID for this document."""
+        return next_revision_id(self._r)

tasks/ip-whithill-hartsong-t1-a/environment/skills/contract-redliner/scripts/mark_reserved.py

@@ -0,0 +1,82 @@
+#!/usr/bin/env python3
+"""Remove an entire numbered section from a .docx contract, in place,
+replacing it with "Reserved." so downstream numbering stays intact.
+
+Usage:
+    python mark_reserved.py CONTRACT.docx --start p-031 --end p-035 \
+        --comment "We removed the on-site audit section because ..." \
+        --author "Jane (AgentCo Legal)"
+
+Tracked-deletes the body text of every paragraph from --start through --end
+(inclusive) and tracked-inserts "Reserved." into the first one. Use this for
+whole-section removal instead of propose_edits.py delete ops. Prints a JSON
+result.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from dataclasses import asdict
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from redline_engine.document import DocumentView  # noqa: E402
+from redline_engine.reserved import mark_paragraph_range_reserved  # noqa: E402
+
+DEFAULT_AUTHOR = "Counsel"
+
+
+
+def _lock_docx(docx_path):
+    """Exclusive cross-process lock for a .docx read-modify-write. opencode can fire parallel bash
+    calls, so two of these scripts may run at once on the same file; without serialization they collide
+    (duplicate comment ids, silently clobbered edits, or a corrupted zip). Hold an flock on a sidecar
+    lock file for the whole load->save; the returned handle keeps the lock until this process exits.
+    Returns None on platforms without fcntl (e.g. Windows) rather than failing."""
+    try:
+        import fcntl
+    except ImportError:
+        return None
+    from pathlib import Path as _P
+    f = open(str(_P(str(docx_path) + ".lock")), "w")
+    fcntl.flock(f.fileno(), fcntl.LOCK_EX)
+    return f
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter
+    )
+    parser.add_argument("docx", help="path to the .docx file (edited in place)")
+    parser.add_argument("--start", required=True, help="first paragraph id of the section, e.g. p-031")
+    parser.add_argument("--end", required=True, help="last paragraph id of the section, e.g. p-035")
+    parser.add_argument("--comment", required=True, help="rationale comment for the removal")
+    parser.add_argument("--author", default=DEFAULT_AUTHOR, help="tracked-change author name")
+    args = parser.parse_args()
+
+    path = Path(args.docx)
+    if not path.exists():
+        print(f"error: file not found: {path}", file=sys.stderr)
+        return 1
+
+    _docx_lock = _lock_docx(path)  # noqa: F841 (held until process exit; serializes concurrent writers)
+    view = DocumentView.load(path)
+    res = mark_paragraph_range_reserved(
+        view,
+        start_paragraph_id=args.start,
+        end_paragraph_id=args.end,
+        comment=args.comment,
+        author=args.author,
+    )
+    view._docx.save(str(path))  # noqa: SLF001
+
+    out = {k: v for k, v in asdict(res).items() if v not in (None, [], "")}
+    print(json.dumps(out, indent=2))
+    return 0 if out.get("status") == "ok" else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

tasks/ip-whithill-hartsong-t1-a/environment/skills/contract-redliner/scripts/propose_edits.py

@@ -0,0 +1,164 @@
+#!/usr/bin/env python3
+"""Apply a batch of tracked-change edits to a .docx contract, in place.
+
+Usage:
+    python propose_edits.py CONTRACT.docx EDITS.json --author "Jane (AgentCo Legal)"
+
+EDITS.json is a JSON array of edit objects:
+
+    [
+      {
+        "op": "replace",                  // "replace" | "delete" | "insert_after" | "insert_paragraph_after"
+        "anchor": {
+          "paragraph_id": "p-027",        // strongly recommended
+          "text": "ninety (90) days",     // verbatim substring of that paragraph
+          "context_before": "within ",    // optional disambiguators
+          "context_after": " after",
+          "occurrence": 1                 // optional, 1-indexed
+        },
+        "new_text": "thirty (30) days",   // required for replace / insert_after / insert_paragraph_after
+        "comment": "We shortened the notice period because ..."  // required
+      }
+
+Ops:
+  * "replace" / "delete"          — tracked edit WITHIN the anchor paragraph.
+  * "insert_after"                — insert new text INLINE, right after the anchor
+                                    span, in the SAME paragraph.
+  * "insert_paragraph_after"      — add a NEW standalone paragraph (a real new
+                                    <w:p>, fully tracked) immediately AFTER the
+                                    anchor paragraph. Use this — not insert_after —
+                                    when a redline must add a new numbered section
+                                    or clause (e.g. "insert as Section 3.5 …");
+                                    insert_after cannot create a new paragraph.
+    ]
+
+Each edit becomes a real Word tracked change (<w:ins>/<w:del>) attributed to
+--author, with the comment attached to the paragraph. Results are printed as
+JSON, one object per edit, in order. Edits are independent: a failed anchor
+does not abort the rest of the batch.
+
+Exit code 0 if every edit applied, 1 if any edit failed (inspect the JSON:
+failed edits have status "anchor_failed" or "runtime_error", and ambiguous
+anchors list candidate paragraph IDs).
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from dataclasses import asdict
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from redline_engine.document import DocumentView  # noqa: E402
+from redline_engine.ops import (  # noqa: E402
+    delete_text,
+    insert_after_text,
+    insert_paragraph_after,
+    replace_text,
+    resolve_revisions,
+)
+
+DEFAULT_AUTHOR = "Counsel"
+
+
+def _apply_one(view: DocumentView, edit: dict, author: str) -> dict:
+    op = edit.get("op")
+    anchor = edit.get("anchor") or {}
+    comment = edit.get("comment", "")
+    new_text = edit.get("new_text", "")
+    if op == "replace":
+        res = replace_text(view, anchor=anchor, new_text=new_text, comment=comment, author=author)
+    elif op == "delete":
+        res = delete_text(view, anchor=anchor, comment=comment, author=author)
+    elif op == "insert_after":
+        res = insert_after_text(
+            view, anchor=anchor, new_text=new_text, comment=comment, author=author
+        )
+    elif op == "insert_paragraph_after":
+        res = insert_paragraph_after(
+            view, anchor=anchor, new_text=new_text, comment=comment, author=author
+        )
+    elif op in ("accept", "reject"):
+        rids = edit.get("revision_ids")
+        if rids is None and edit.get("revision_id") is not None:
+            rids = [edit["revision_id"]]
+        res = resolve_revisions(
+            view, revision_ids=rids or [], disposition=op, comment=comment, author=author
+        )
+    else:
+        return {"op": str(op), "status": "runtime_error", "error": f"unknown op: {op!r}"}
+    return {k: v for k, v in asdict(res).items() if v not in (None, [], "")}
+
+
+
+def _lock_docx(docx_path):
+    """Exclusive cross-process lock for a .docx read-modify-write. opencode can fire parallel bash
+    calls, so two of these scripts may run at once on the same file; without serialization they collide
+    (duplicate comment ids, silently clobbered edits, or a corrupted zip). Hold an flock on a sidecar
+    lock file for the whole load->save; the returned handle keeps the lock until this process exits.
+    Returns None on platforms without fcntl (e.g. Windows) rather than failing."""
+    try:
+        import fcntl
+    except ImportError:
+        return None
+    from pathlib import Path as _P
+    f = open(str(_P(str(docx_path) + ".lock")), "w")
+    fcntl.flock(f.fileno(), fcntl.LOCK_EX)
+    return f
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter
+    )
+    parser.add_argument("docx", help="path to the .docx file (edited in place)")
+    parser.add_argument("edits", help="path to a JSON file with the edits array, or '-' for stdin")
+    parser.add_argument("--author", default=DEFAULT_AUTHOR, help="tracked-change author name")
+    args = parser.parse_args()
+
+    path = Path(args.docx)
+    if not path.exists():
+        print(f"error: file not found: {path}", file=sys.stderr)
+        return 1
+
+    raw = sys.stdin.read() if args.edits == "-" else Path(args.edits).read_text()
+    try:
+        edits = json.loads(raw)
+    except json.JSONDecodeError as exc:
+        print(f"error: edits file is not valid JSON: {exc}", file=sys.stderr)
+        return 1
+    if not isinstance(edits, list):
+        print("error: edits must be a JSON array of edit objects", file=sys.stderr)
+        return 1
+
+    _docx_lock = _lock_docx(path)  # noqa: F841 (held until process exit; serializes concurrent writers)
+    view = DocumentView.load(path)
+    results = []
+    for edit in edits:
+        if not isinstance(edit, dict):
+            results.append(
+                {
+                    "op": "unknown",
+                    "status": "runtime_error",
+                    "error": f"each edit must be an object; got {type(edit).__name__}",
+                }
+            )
+            continue
+        results.append(_apply_one(view, edit, args.author))
+
+    view._docx.save(str(path))  # noqa: SLF001 — mirrors the engine's save convention
+
+    print(json.dumps({"applied_to": str(path), "results": results}, indent=2))
+    failed = sum(1 for r in results if r.get("status") != "ok")
+    if failed:
+        print(f"\n{failed}/{len(results)} edits FAILED — fix anchors and resubmit only those.",
+              file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

tasks/ip-whithill-hartsong-t1-a/environment/skills/contract-redliner/scripts/read_document.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+"""Print a .docx contract as Markdown with stable paragraph IDs.
+
+Usage:
+    python read_document.py CONTRACT.docx [--max-chars N]
+
+Output: a stats line, then the document as Markdown. Each paragraph is
+prefixed with its ID like `[p-027]`. Paragraphs carrying tracked changes or
+comments are flagged, and an appendix lists every existing comment (cmt-N)
+and tracked change (rev-N) with its author and text.
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from redline_engine.document import DocumentView  # noqa: E402
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("docx", help="path to the .docx file")
+    parser.add_argument(
+        "--max-chars",
+        type=int,
+        default=None,
+        help="truncate output after N characters (default: no limit)",
+    )
+    args = parser.parse_args()
+
+    path = Path(args.docx)
+    if not path.exists():
+        print(f"error: file not found: {path}", file=sys.stderr)
+        return 1
+
+    view = DocumentView.load(path)
+    stats = view.stats()
+    try:
+        print(f"# stats: {stats}")
+        print(view.to_markdown(max_chars=args.max_chars))
+    except BrokenPipeError:  # e.g. piped to `head`
+        sys.stderr.close()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

tasks/ip-whithill-hartsong-t1-a/environment/skills/contract-redliner/scripts/redline_engine/anchoring.py

@@ -0,0 +1,271 @@
+"""Resolve LLM-supplied anchors to (paragraph_id, char_start, char_end) positions.
+
+The LLM's anchor schema is::
+
+    {
+      "paragraph_id": "p-027",        # required when we can; primary key
+      "text": "non-exclusive, royalty-free",  # exact text to find inside that paragraph
+      "context_before": "...",        # optional, used to disambiguate when text appears twice
+      "context_after": "...",         # optional, same purpose
+      "occurrence": 1                 # optional, 1-indexed, defaults to 1
+    }
+
+We match against the paragraph's **accepted text** — the text as it reads with
+prior insertions kept and prior deletions removed — so the model can anchor to
+text a counterparty inserted on an earlier turn (a response-turn doc is full of
+such text). We fold smart quotes / dashes / whitespace before matching, but map
+the match back to **exact offsets into the accepted text** so the applied edit
+lands on the real characters (a `normalize`-vs-raw offset skew previously caused
+`Invalid offsets` runtime errors). A fail-loud invariant rejects any anchor whose
+recovered span doesn't fold back to the needle, so a bad map degrades to a clean
+`anchor_failed` rather than a silently mis-placed edit.
+
+Resolution reads the **live** paragraph each call (not a load-time snapshot), so
+a batch of edits on one paragraph doesn't drift on stale offsets.
+"""
+
+from __future__ import annotations
+
+import re
+import unicodedata
+from dataclasses import dataclass
+from typing import Optional
+
+from docx_revisions import RevisionParagraph
+
+from .document import DocumentView
+
+
+# Smart quote / dash / whitespace folding. LLMs love re-typing curly quotes
+# slightly differently than the source; this is the most common false-mismatch.
+_QUOTE_MAP = str.maketrans(
+    {
+        "‘": "'",  # left single quote
+        "’": "'",  # right single quote
+        "‚": "'",  # single low-9 quote
+        "‛": "'",  # single high-reversed-9 quote
+        "“": '"',  # left double quote
+        "”": '"',  # right double quote
+        "„": '"',  # double low-9 quote
+        "‟": '"',  # double high-reversed-9 quote
+        "–": "-",  # en dash
+        "—": "-",  # em dash
+        "−": "-",  # minus sign
+        "\xa0": " ",  # non-breaking space
+    }
+)
+
+_WHITESPACE_RE = re.compile(r"\s+")
+
+
+def normalize(text: str) -> str:
+    """Normalize text for robust matching. Idempotent.
+
+    NFC → smart-quote/dash fold → whitespace collapse → strip. Used for the
+    needle, the context strings, and the fail-loud invariant. `normalize_with_map`
+    produces the same output for the haystack but also returns an index map back
+    to the raw (accepted-text) offsets.
+    """
+    if not text:
+        return ""
+    text = unicodedata.normalize("NFC", text)
+    text = text.translate(_QUOTE_MAP)
+    text = _WHITESPACE_RE.sub(" ", text)
+    return text.strip()
+
+
+def normalize_with_map(raw: str) -> tuple[str, list[int]]:
+    """Fold `raw` the same way `normalize` does, but return `(norm, idx_map)`
+    where `idx_map[i]` is the index into `raw` of `norm[i]` (and `idx_map[len]`
+    is the index one past the last consumed char). This lets a match at
+    `norm[s:e]` recover the exact raw span `raw[idx_map[s]:idx_map[e]]`.
+
+    NFC is deliberately **not** applied here: the offsets must line up with the
+    real `accepted_text` the vendored `replace_tracked_at(index_mode="accepted")`
+    indexes. `_QUOTE_MAP` is a 1:1 translation (index-preserving); only the
+    whitespace collapse is many:1, which the map records. For the NFC-stable
+    contract text this yields the same folded string as `normalize`; any residual
+    difference is caught by the fail-loud invariant in `resolve`.
+    """
+    raw = raw or ""
+    translated = raw.translate(_QUOTE_MAP)  # 1:1 — indices match `raw`
+    out: list[str] = []
+    idx: list[int] = []
+    pos = 0
+    n = len(translated)
+    for m in _WHITESPACE_RE.finditer(translated):
+        for k in range(pos, m.start()):
+            out.append(translated[k])
+            idx.append(k)
+        out.append(" ")
+        idx.append(m.start())
+        pos = m.end()
+    for k in range(pos, n):
+        out.append(translated[k])
+        idx.append(k)
+    idx.append(n)  # sentinel: one past the end
+    norm = "".join(out)
+    # Replicate `.strip()`: after collapse, boundary whitespace is single spaces.
+    lo, hi = 0, len(norm)
+    while lo < hi and norm[lo] == " ":
+        lo += 1
+    while hi > lo and norm[hi - 1] == " ":
+        hi -= 1
+    return norm[lo:hi], idx[lo:hi] + [idx[hi]]
+
+
+@dataclass
+class ResolvedAnchor:
+    paragraph_id: str
+    # The exact matched substring of the paragraph's accepted text, and its
+    # offsets into that accepted text. Ops apply with index_mode="accepted".
+    raw_text: str
+    start: int
+    end: int
+
+
+@dataclass
+class AnchorError:
+    """Structured failure that gets handed back to the LLM."""
+
+    kind: str  # "paragraph_not_found" | "text_not_found" | "ambiguous" | "no_paragraph_id"
+    message: str
+    # For ambiguous matches, list the paragraph IDs that contained the text.
+    candidates: list[str] | None = None
+
+
+def _accepted_text(view: DocumentView, paragraph_id: str) -> Optional[str]:
+    """The LIVE accepted text of a paragraph (insertions kept, deletions removed),
+    read fresh from the runtime element so a batch of edits sees prior mutations.
+    """
+    para = view.runtime_paragraph(paragraph_id)
+    if para is None:
+        return None
+    return RevisionParagraph.from_paragraph(para).accepted_text
+
+
+def resolve(view: DocumentView, anchor: dict) -> ResolvedAnchor | AnchorError:
+    """Resolve an LLM anchor dict to a `ResolvedAnchor` or `AnchorError`."""
+    paragraph_id: Optional[str] = anchor.get("paragraph_id")
+    text: Optional[str] = anchor.get("text")
+    # `occurrence` is explicit (None = let resolver decide; only works when unique).
+    occurrence_raw = anchor.get("occurrence")
+    occurrence: int | None = int(occurrence_raw) if occurrence_raw is not None else None
+    context_before: str = normalize(anchor.get("context_before", "") or "")
+    context_after: str = normalize(anchor.get("context_after", "") or "")
+
+    if not text:
+        return AnchorError("text_not_found", "anchor.text is required and must be non-empty")
+
+    needle = normalize(text)
+    if not needle:
+        return AnchorError("text_not_found", "anchor.text normalizes to empty")
+
+    # If paragraph_id is supplied, restrict the search to that paragraph.
+    if paragraph_id:
+        raw = _accepted_text(view, paragraph_id)
+        if raw is None:
+            return AnchorError(
+                "paragraph_not_found",
+                f"no paragraph with id={paragraph_id!r}",
+            )
+        return _resolve_within_paragraph(
+            paragraph_id, raw, text, needle, context_before, context_after, occurrence
+        )
+
+    # No paragraph_id — search the whole doc (live accepted text per paragraph).
+    candidates: list[tuple[str, int, int, str]] = []
+    for p in view.paragraphs:
+        raw = _accepted_text(view, p.id)
+        if not raw or not raw.strip():
+            continue
+        norm, idx_map = normalize_with_map(raw)
+        for m in re.finditer(re.escape(needle), norm):
+            if _context_matches(norm, m.start(), m.end(), context_before, context_after):
+                rs, re_ = idx_map[m.start()], idx_map[m.end()]
+                candidates.append((p.id, rs, re_, raw))
+
+    if not candidates:
+        return AnchorError(
+            "text_not_found",
+            f"text {text!r} not found in any paragraph (after normalization)",
+        )
+    if len(candidates) > 1:
+        if occurrence is None or not (1 <= occurrence <= len(candidates)):
+            return AnchorError(
+                "ambiguous",
+                f"text {text!r} appears {len(candidates)} times; "
+                "provide paragraph_id, context_before/after, or occurrence",
+                candidates=[c[0] for c in candidates],
+            )
+        pid, rs, re_, raw = candidates[occurrence - 1]
+    else:
+        pid, rs, re_, raw = candidates[0]
+    return _finalize(pid, raw, rs, re_, needle)
+
+
+def _resolve_within_paragraph(
+    paragraph_id: str,
+    raw_text: str,
+    original_text: str,
+    needle: str,
+    context_before: str,
+    context_after: str,
+    occurrence: int | None,
+) -> ResolvedAnchor | AnchorError:
+    norm, idx_map = normalize_with_map(raw_text)
+    matches: list[tuple[int, int]] = []
+    for m in re.finditer(re.escape(needle), norm):
+        if _context_matches(norm, m.start(), m.end(), context_before, context_after):
+            matches.append((idx_map[m.start()], idx_map[m.end()]))
+    if not matches:
+        return AnchorError(
+            "text_not_found",
+            f"text {original_text!r} not found in paragraph {paragraph_id}",
+        )
+    if len(matches) > 1:
+        if occurrence is None or not (1 <= occurrence <= len(matches)):
+            return AnchorError(
+                "ambiguous",
+                f"text {original_text!r} appears {len(matches)} times in {paragraph_id}; "
+                "supply occurrence",
+                candidates=[paragraph_id],
+            )
+        rs, re_ = matches[occurrence - 1]
+    else:
+        rs, re_ = matches[0]
+    return _finalize(paragraph_id, raw_text, rs, re_, needle)
+
+
+def _finalize(
+    paragraph_id: str, raw: str, start: int, end: int, needle: str
+) -> ResolvedAnchor | AnchorError:
+    """Build a ResolvedAnchor after checking the offset-map invariant."""
+    span = raw[start:end]
+    if normalize(span) != needle:
+        # The index map disagrees with the match — refuse rather than apply an
+        # edit to the wrong characters (this is the class of bug that produced
+        # `Invalid offsets` / wrong-text deletes).
+        return AnchorError(
+            "text_not_found",
+            f"anchor offset-map invariant failed in {paragraph_id} "
+            f"(recovered {span!r} != {needle!r})",
+        )
+    return ResolvedAnchor(paragraph_id=paragraph_id, raw_text=span, start=start, end=end)
+
+
+def _context_matches(hay: str, start: int, end: int, before: str, after: str) -> bool:
+    """Both context fields are optional; absent → always matches.
+
+    Boundaries are whitespace-trimmed before comparing: `normalize()` strips
+    the context strings, so a context like "at least " must still match even
+    though the paragraph has a space between it and the anchored text.
+    """
+    if before:
+        # The chars immediately before `start` should end with `before`.
+        if not hay[:start].rstrip().endswith(before):
+            return False
+    if after:
+        if not hay[end:].lstrip().startswith(after):
+            return False
+    return True