winter-super-cli 2026.5.26 → 2026.5.27

package/resources/local/codex/plugins/cache/openai-primary-runtime/documents/26.505.10851/skills/documents/scripts/watermark_audit_remove.py

@@ -1,145 +0,0 @@
-#!/usr/bin/env python3
-"""Audit and (heuristically) remove watermark-like background elements.
-
-In Word, watermarks are often implemented as VML shapes in headers:
-  w:hdr -> w:p -> w:r -> w:pict -> v:shape -> v:textpath string="DRAFT"
-
-python-docx doesn't expose these well; LO vs Word rendering can differ; therefore
-this helper focuses on OOXML inspection/removal with mandatory render + diff.
-
-Modes
------
-- report: list watermark-like occurrences (VML or DrawingML) across document+headers+footers
-- remove: delete matched objects whose embedded watermark text contains a substring
-
-Usage
------
-python scripts/watermark_audit_remove.py in.docx --mode report
-python scripts/watermark_audit_remove.py in.docx --mode remove --contains DRAFT --out out.docx
-"""
-
-from __future__ import annotations
-
-import argparse
-import re
-import zipfile
-
-from lxml import etree
-
-W_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main"
-V_NS = "urn:schemas-microsoft-com:vml"
-R_NS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
-
-NS = {"w": W_NS, "v": V_NS, "r": R_NS}
-
-
-def _xml_bytes(root: etree._Element) -> bytes:
-    return etree.tostring(root, xml_declaration=True, encoding="UTF-8", standalone="yes")
-
-
-def _read_xml(z: zipfile.ZipFile, name: str) -> etree._Element:
-    return etree.fromstring(z.read(name))
-
-
-def _find_doc_parts(z: zipfile.ZipFile) -> list[str]:
-    parts = ["word/document.xml"]
-    for name in z.namelist():
-        if re.fullmatch(r"word/header\d+\.xml", name) or re.fullmatch(r"word/footer\d+\.xml", name):
-            parts.append(name)
-    return sorted(set(parts))
-
-
-def _scan_part(root: etree._Element) -> list[dict]:
-    hits = []
-
-    # VML watermark-like textpath
-    for tp in root.xpath(".//v:textpath", namespaces=NS):
-        s = tp.get("string") or ""
-        if s.strip():
-            hits.append({"kind": "vml_textpath", "text": s.strip()})
-
-    # Fallback: any element with 'watermark' in attributes
-    for el in root.iter():
-        for v in el.attrib.values():
-            if isinstance(v, str) and "watermark" in v.lower():
-                hits.append({"kind": "attr_watermark", "text": v})
-                break
-
-    return hits
-
-
-def report(docx: str) -> int:
-    with zipfile.ZipFile(docx, "r") as z:
-        parts = _find_doc_parts(z)
-        total = 0
-        for part in parts:
-            root = _read_xml(z, part)
-            hits = _scan_part(root)
-            if hits:
-                print(f"[{part}]")
-                for h in hits[:50]:
-                    print(f"  - {h['kind']}: {h['text']}")
-                total += len(hits)
-        print(f"[summary] watermark_like_hits={total}")
-        return total
-
-
-def remove(docx: str, out: str, contains: str) -> None:
-    contains_l = contains.lower()
-    with zipfile.ZipFile(docx, "r") as zin:
-        parts = _find_doc_parts(zin)
-        overrides: dict[str, bytes] = {}
-
-        for part in parts:
-            root = _read_xml(zin, part)
-            changed = False
-
-            # Remove any w:pict that contains a v:textpath string matching substring
-            for pict in root.xpath(".//w:pict", namespaces=NS):
-                tps = pict.xpath(".//v:textpath", namespaces=NS)
-                hit = False
-                for tp in tps:
-                    s = (tp.get("string") or "").lower()
-                    if contains_l in s:
-                        hit = True
-                        break
-                if hit:
-                    parent = pict.getparent()
-                    if parent is not None:
-                        parent.remove(pict)
-                        changed = True
-
-            if changed:
-                overrides[part] = _xml_bytes(root)
-
-        with zipfile.ZipFile(out, "w", zipfile.ZIP_DEFLATED) as zout:
-            for info in zin.infolist():
-                name = info.filename
-                if name in overrides:
-                    zout.writestr(name, overrides[name])
-                else:
-                    zout.writestr(name, zin.read(name))
-
-    print(f"[OK] wrote {out}")
-
-
-def main() -> None:
-    ap = argparse.ArgumentParser()
-    ap.add_argument("in_docx")
-    ap.add_argument("--mode", choices=["report", "remove"], required=True)
-    ap.add_argument("--contains", help="Substring to match for removal")
-    ap.add_argument("--out", help="Output docx for remove")
-    args = ap.parse_args()
-
-    if args.mode == "report":
-        report(args.in_docx)
-        return
-
-    if not args.contains or not args.out:
-        ap.error("--contains and --out are required when --mode remove")
-
-    remove(args.in_docx, args.out, args.contains)
-
-
-if __name__ == "__main__":
-    main()

package/resources/local/codex/plugins/cache/openai-primary-runtime/documents/26.505.10851/skills/documents/scripts/xlsx_to_docx_table.py

@@ -1,179 +0,0 @@
-#!/usr/bin/env python3
-"""Convert an XLSX worksheet to a simple DOCX table.
-
-Scope
------
-This is a "minimum useful" converter intended for reports:
-- Reads values from a sheet
-- Creates a DOCX with a grid table
-- Applies a few common-sense formats (header bold, basic alignment)
-- Uses heuristic column widths based on max content length
-
-Limits
-------
-- It does NOT reproduce Excel formulas, merged cells, conditional formatting, charts, or complex number formats.
-- Number formatting is best-effort. If you need exact appearance, consider exporting the range as an image instead.
-"""
-
-from __future__ import annotations
-
-import argparse
-import datetime as _dt
-import os
-import sys
-from pathlib import Path
-
-from docx import Document
-from docx.enum.text import WD_ALIGN_PARAGRAPH
-from docx.oxml import OxmlElement
-from docx.oxml.ns import qn
-from docx.shared import Inches
-from openpyxl import load_workbook
-
-
-def _mark_row_as_header(row) -> None:
-    """Mark a table row as a repeating header row (w:tblHeader).
-
-    This improves accessibility and ensures header rows repeat when the table
-    spans multiple pages.
-    """
-
-    tr = row._tr  # python-docx internal
-    trPr = tr.get_or_add_trPr()
-    # Avoid duplicating if re-run
-    if trPr.find(qn("w:tblHeader")) is None:
-        trPr.append(OxmlElement("w:tblHeader"))
-
-
-def _is_empty(v) -> bool:
-    if v is None:
-        return True
-    if isinstance(v, str) and not v.strip():
-        return True
-    return False
-
-
-def _best_effort_format(cell) -> str:
-    v = cell.value
-    if v is None:
-        return ""
-    if isinstance(v, (bool, int)):
-        return str(v)
-    if isinstance(v, float):
-        fmt = (cell.number_format or "").lower()
-        if "%" in fmt:
-            return f"{v * 100:.2f}%"
-        if "$" in fmt:
-            return f"${v:,.2f}"
-        return f"{v:g}"
-    if isinstance(v, (_dt.datetime, _dt.date)):
-        try:
-            return v.isoformat()
-        except Exception:
-            return str(v)
-    return str(v)
-
-
-def _used_bounds(ws):
-    # Compute a tight-ish used range; ws.max_row/col may include trailing empties.
-    max_r = 0
-    max_c = 0
-    for row in ws.iter_rows():
-        for cell in row:
-            if not _is_empty(cell.value):
-                max_r = max(max_r, cell.row)
-                max_c = max(max_c, cell.column)
-    return max_r, max_c
-
-
-def main() -> None:
-    ap = argparse.ArgumentParser(description="Convert an XLSX sheet to a DOCX table")
-    ap.add_argument("xlsx", type=Path)
-    # Keep the original positional output path for backwards compatibility, but also
-    # support an --out alias (agents often assume this flag exists).
-    ap.add_argument("out_docx", type=Path, nargs="?", default=None)
-    ap.add_argument("--out", type=Path, default=None, help="Output DOCX path (alias)")
-    ap.add_argument("--sheet", default=None, help="Sheet name (default: active)")
-    ap.add_argument("--header_rows", type=int, default=1, help="How many top rows to bold")
-    ap.add_argument("--title", default=None, help="Optional title paragraph above the table")
-    args = ap.parse_args()
-
-    out_path = args.out or args.out_docx
-    if out_path is None:
-        raise RuntimeError("Missing output path. Provide a positional out_docx or --out.")
-
-    if not args.xlsx.exists():
-        raise FileNotFoundError(args.xlsx)
-    out_path.parent.mkdir(parents=True, exist_ok=True)
-
-    wb = load_workbook(args.xlsx, data_only=True)
-    ws = wb[args.sheet] if args.sheet else wb.active
-
-    max_r, max_c = _used_bounds(ws)
-    if max_r == 0 or max_c == 0:
-        raise RuntimeError("Sheet appears empty")
-
-    # Gather formatted strings for width heuristics
-    data = []
-    col_max_len = [0] * max_c
-    for r in range(1, max_r + 1):
-        row_vals = []
-        for c in range(1, max_c + 1):
-            cell = ws.cell(row=r, column=c)
-            s = _best_effort_format(cell)
-            row_vals.append(s)
-            col_max_len[c - 1] = max(col_max_len[c - 1], len(s))
-        data.append(row_vals)
-
-    doc = Document()
-    if args.title:
-        doc.add_paragraph(args.title)
-
-    table = doc.add_table(rows=max_r, cols=max_c)
-    table.style = "Table Grid"
-    table.autofit = False
-
-    # Column widths (heuristic): ~0.12in per char, clamped
-    col_widths = []
-    for ml in col_max_len:
-        w = max(0.8, min(3.0, 0.12 * max(ml, 4)))
-        col_widths.append(w)
-
-    for r in range(max_r):
-        for c in range(max_c):
-            cell = ws.cell(row=r + 1, column=c + 1)
-            out = table.cell(r, c)
-            out.width = Inches(col_widths[c])
-            p = out.paragraphs[0]
-            p.text = data[r][c]
-
-            # Alignment best-effort
-            horiz = getattr(cell.alignment, "horizontal", None)
-            if horiz in {"right", "center", "left"}:
-                p.alignment = {
-                    "left": WD_ALIGN_PARAGRAPH.LEFT,
-                    "center": WD_ALIGN_PARAGRAPH.CENTER,
-                    "right": WD_ALIGN_PARAGRAPH.RIGHT,
-                }[horiz]
-
-            # Bold header rows
-            if r < args.header_rows and p.runs:
-                for run in p.runs:
-                    run.bold = True
-
-        # Mark header rows in OOXML for a11y + repeating headers
-        if r < args.header_rows:
-            _mark_row_as_header(table.rows[r])
-
-    doc.save(str(out_path))
-    print(f"[OK] Wrote {out_path} (rows={max_r}, cols={max_c}, sheet={ws.title!r})")
-
-
-if __name__ == "__main__":
-    try:
-        main()
-    except Exception as e:
-        if os.environ.get("DOCS_DEBUG") == "1":
-            raise
-        print(f"[ERROR] {e}", file=sys.stderr)
-        raise SystemExit(2)

package/resources/local/codex/plugins/cache/openai-primary-runtime/documents/26.505.10851/skills/documents/tasks/accessibility_a11y.md

@@ -1,55 +0,0 @@
-# Accessibility (A11y) Audit + Quick Fixes
-
-## Goal
-Given a `.docx`, produce an **accessibility audit report** and (optionally) apply **safe, mechanical fixes** that reduce common A11y failures.
-
-This is **not** a full WCAG compliance engine. It targets the highest-ROI checks you can do reliably in OOXML:
-- Heading hierarchy (no skipping levels)
-- Images missing alt text (`descr`)
-- Tables missing a header row flag
-- Hyperlink text that is non-descriptive ("click here", raw URLs)
-
-## Audit
-```bash
-python scripts/a11y_audit.py input.docx
-```
-
-This prints a JSON-ish report to stdout and exits non-zero if **high severity** issues exist.
-
-To write the report to a file instead:
-```bash
-python scripts/a11y_audit.py input.docx --out_json a11y_report.json
-```
-
-## Apply quick fixes (optional)
-### 1) Fill missing image alt text using filenames
-This is a pragmatic baseline that is better than empty alt text.
-```bash
-python scripts/a11y_audit.py input.docx --fix_image_alt from_filename --out a11y_fixed.docx
-```
-
-### 2) Mark first row as a table header
-Only do this when the first row *is actually* a header.
-```bash
-python scripts/a11y_audit.py input.docx --fix_table_headers first_row --out a11y_fixed.docx
-```
-
-You can combine fixes:
-```bash
-python scripts/a11y_audit.py input.docx \
-  --fix_image_alt from_filename \
-  --fix_table_headers first_row \
-  --out a11y_fixed.docx
-```
-
-## Verification loop
-1) Apply fixes (if any)
-2) **Render → inspect PNGs** to confirm nothing drifted visually:
-```bash
-python render_docx.py a11y_fixed.docx --output_dir out_a11y
-```
-
-## Pitfalls
-- "Fixing" headings is rarely mechanical; it usually requires editorial judgement. This tool **reports** heading issues but does not rewrite styles.
-- Setting table header flags can change repeated header rendering across page breaks. Always re-render and review.
-- Alt text generated from filenames is a baseline; replace it with meaningful descriptions for real accessibility.

package/resources/local/codex/plugins/cache/openai-primary-runtime/documents/26.505.10851/skills/documents/tasks/captions_crossrefs.md

@@ -1,97 +0,0 @@
-# Task: Captions + cross-references (SEQ + REF)
-
-## When to use
-Use this when the user wants:
-- **Figure/Table captions** ("Figure 1", "Table 2"…)
-- **Cross-references** ("see Figure 3")
-- **Stable numbering** for headless rendering/QA
-
-Word implements captions/cross-references using fields:
-- `SEQ` for numbering (e.g., `SEQ Table` / `SEQ Figure`)
-- `REF` to reference a bookmark (cross-reference target)
-
-`python-docx` does not provide a high-level API for these fields, so this bundle uses OOXML-level helpers:
-- `scripts/captions_and_crossrefs.py` — insert caption paragraphs + optional bookmarks around the caption number
-- `scripts/insert_ref_fields.py` — replace `[[REF:bookmark]]` markers with real `REF` fields
-- `scripts/fields_materialize.py` — materialize `SEQ/REF` *display text* so headless renders show the correct numbers
-
-## The practical gotcha
-Fields **do not reliably update** in headless environments. If you only insert field codes (`SEQ`/`REF`), the rendered number may be blank or stale.
-
-For deterministic automation / QA, the reliable pattern is:
-1) insert field codes, then
-2) **materialize** the field display text
-
-A human can still open the document later and update fields, but for automation you want deterministic visuals.
-
----
-
-## Workflow
-
-### 1) Add captions (and bookmarks)
-This adds captions for tables and/or figures that don't already have a `Caption` paragraph immediately after them.
-
-```bash
-python scripts/captions_and_crossrefs.py \
-  /mnt/data/in.docx \
-  /mnt/data/with_captions.docx \
-  --tables --figures \
-  --caption_text "Caption" \
-  --bookmarks
-```
-
-What it does:
-- Inserts a `Caption`-styled paragraph after each table / figure paragraph.
-- Uses a `SEQ Table` / `SEQ Figure` field for numbering.
-- If `--bookmarks` is set, wraps the *caption number* in a bookmark:
-  - tables: `tbl1`, `tbl2`, …
-  - figures: `fig1`, `fig2`, …
-
-### 2) Insert cross-references (REF)
-**Authoring trick:** put explicit markers into the doc where you want a cross-ref, e.g.
-- `See [[REF:tbl1]] for details.`
-- `As shown in [[REF:fig1]] …`
-
-Then replace markers with real `REF` fields:
-
-```bash
-python scripts/insert_ref_fields.py \
-  /mnt/data/with_captions.docx \
-  /mnt/data/with_refs.docx
-```
-
-Notes:
-- This script replaces markers in `document.xml` and headers/footers.
-- Multiple `[[REF:...]]` markers inside a single text run are supported.
-- **Limitation:** the marker must be fully contained in a single text run (`<w:t>`). If Word split the marker across runs, retype it as a single contiguous token.
-
-### 3) Materialize (freeze) SEQ/REF results for deterministic renders
-```bash
-python scripts/fields_materialize.py \
-  /mnt/data/with_refs.docx \
-  --out /mnt/data/with_refs_materialized.docx
-```
-
-Implementation note: `fields_materialize.py` materializes `SEQ` values before `REF` values so cross-references see the updated caption numbers.
-
-If you only want to materialize one type:
-```bash
-python scripts/fields_materialize.py /mnt/data/with_refs.docx --out /mnt/data/out.docx --only REF
-```
-
-### 4) Render and visually QA
-```bash
-python render_docx.py /mnt/data/with_refs_materialized.docx --output_dir /mnt/data/out_caps
-```
-Inspect the PNGs.
-
----
-
-## Pitfalls / tips
-- **Caption style availability:** if the document doesn’t define a `Caption` style, captions may appear as Normal text. If the user cares, apply a template/style pack first.
-- **Figures detection:** this script treats paragraphs containing a `<w:drawing>`/`<w:pict>` as a "figure paragraph".
-- **Edits after materializing:** if you insert/remove figures/tables later, re-run `fields_materialize.py` to recompute numbering.
-
-## Deliverables
-- Deliver **only the final DOCX** requested by the user.
-- PNGs / optional PDFs are internal QA only unless explicitly requested.

package/resources/local/codex/plugins/cache/openai-primary-runtime/documents/26.505.10851/skills/documents/tasks/clean_tracked_changes.md

@@ -1,44 +0,0 @@
-# Accept / Reject Tracked Changes (produce a clean DOCX)
-
-## Goal
-Given a `.docx` with tracked changes (redlines), produce a **final clean** copy with changes accepted (or rejected), and verify visually.
-
-## What tracked changes are (OOXML)
-Tracked changes are usually wrappers in `word/document.xml`:
-- `w:ins` — inserted content
-- `w:del` — deleted content
-- sometimes: `w:moveTo` / `w:moveFrom` for moved text
-
-Many “looks wrong” reports come from:
-- leaving revisions in place (Word shows redlines; LO export may hide/show inconsistently)
-- stale renders (you didn’t re-render after patching)
-
-## Steps
-1. **Inspect** how many revisions exist:
-   ```bash
-   python scripts/accept_tracked_changes.py input.docx --mode report
-   ```
-2. **Accept** all tracked changes into a clean copy:
-   ```bash
-   python scripts/accept_tracked_changes.py input.docx --mode accept --out accepted.docx
-   ```
-   (Or reject):
-   ```bash
-   python scripts/accept_tracked_changes.py input.docx --mode reject --out rejected.docx
-   ```
-3. **Render → PNG review** (required):
-   ```bash
-   python render_docx.py accepted.docx --output_dir out_accept
-   ```
-
-## Render → PNG review checklist
-Open all `out_accept/page-*.png` at 100% zoom:
-- No redlines/strikethrough remain
-- No missing words (especially around the edited region)
-- No spacing drift caused by removed wrappers
-- Headers/footers still correct
-
-## Pitfalls
-- This is a pragmatic helper, not a perfect Word revision engine.
-- Always re-run `--mode report` on the output; it should be zero.
-- If Word-specific revision constructs remain, fall back to “Open in Word → Accept All → Save As” and re-render.

package/resources/local/codex/plugins/cache/openai-primary-runtime/documents/26.505.10851/skills/documents/tasks/comments_manage.md

@@ -1,71 +0,0 @@
-# Comments: Extract, Remove, or Preserve for Review
-
-## Goal
-Handle reviewer comments in a `.docx` without confusing intermediate artifacts.
-
-Common situations:
-- **Review mode**: keep comments and deliver a commented `.docx`.
-- **Final mode**: remove comments (and optionally accept tracked changes) and deliver a clean `.docx`.
-- **Triage mode**: extract comments into a machine-readable report (JSON/Markdown) for summarization.
-
-> Word "resolved" state is not reliably round-trippable with `python-docx` alone. This skill focuses on **reliable** operations.
-
-## Adding comments (true Word comments)
-If the task is to *insert* new comments (not just extract/strip), use the OOXML-level guide: `ooxml/comments.md` (via `scripts/docx_ooxml_patch.py`).
-
-## Add comments at scale (review mode)
-For programmatic review injection (multiple comments across the document), use:
-```bash
-python scripts/comments_add.py input.docx --out reviewed.docx --author "Reviewer"   --add "Payment Terms=Please confirm Net 45 is acceptable."   --add "Governing Law=Prefer Delaware; any constraints?"   --ignore_case
-```
-Notes:
-- Matching looks across normal text **and** deleted text (`w:delText`), so it can still find anchors in docs with tracked changes.
-- The script warns on patterns with no matches; add `--require_all` to fail fast.
-
-## Patch / resolve existing comments
-For updating or marking comments as resolved:
-```bash
-python scripts/comments_extract.py reviewed.docx --out comments.json
-
-# Create a separate patch file (JSON). Example:
-# {
-#   "ops": [
-#     {"id": 0, "append": "Follow-up note"},
-#     {"id": 0, "replace": "Full replacement text"},
-#     {"id": 0, "resolved": true}
-#   ]
-# }
-# (Set "resolved": false to clear the resolved state.)
-
-python scripts/comments_apply_patch.py reviewed.docx patch.json --out reviewed_v2.docx
-```
-
-
-
-## Extract comments (triage)
-Produces JSON with comment text, author, date (if present), and the anchored snippet.
-```bash
-python scripts/comments_extract.py input.docx --out comments.json
-```
-
-## Remove all comments (final mode)
-This removes:
-- comment ranges and references in story parts (main doc + headers/footers)
-- `word/comments.xml` and any comment-related relationships / content type overrides
-
-```bash
-python scripts/comments_strip.py input.docx --out no_comments.docx
-```
-
-## Recommended finalize workflow
-If the requested deliverable is a **clean final DOCX**:
-```bash
-python scripts/accept_tracked_changes.py input.docx --mode accept --out accepted.docx
-python scripts/comments_strip.py accepted.docx --out final_clean.docx
-python render_docx.py final_clean.docx --output_dir out_final_clean
-```
-
-## Pitfalls
-- Comments can be anchored in headers/footers too; always strip across all story parts.
-- Some docs include `commentsExtended.xml` (newer Word). This script removes it if present.
-- After stripping, render PNGs and verify nothing disappeared around comment anchors.

package/resources/local/codex/plugins/cache/openai-primary-runtime/documents/26.505.10851/skills/documents/tasks/compare_diff.md

@@ -1,32 +0,0 @@
-# Compare / Diff Two DOCXs (visual + structural)
-
-## Goal
-Given two `.docx` files, produce an easy QA bundle:
-- renders of both docs (`page-*.png`)
-- per-page diff images for changed pages
-- a text-level unified diff
-
-This is high-ROI for regression testing and reviewer confidence.
-
-## Steps
-1. Run the helper:
-   ```bash
-   python scripts/render_and_diff.py a.docx b.docx --outdir diff_out
-   ```
-
-2. Inspect:
-   - `diff_out/a_render/page-*.png`
-   - `diff_out/b_render/page-*.png`
-   - `diff_out/diff_pages/diff-page-*.png`
-   - `diff_out/text_diff.txt`
-
-## Render → PNG review checklist
-- Confirm page counts match expectations
-- Open **each changed page** in both A and B at 100% zoom
-- Verify the visual diff highlights only intended changes
-- Spot-check unchanged pages if the edit is layout-sensitive (tables/images/sections)
-
-## Pitfalls
-- LO headless rendering can differ from Word; this tool catches visual diffs in *your* render loop, which is what you ship.
-- If pagination differs, many pages may show as changed. Use the text diff to confirm content-level changes.
-- If you see changes that are *only* anti-aliasing noise, increase render DPI and re-run.

package/resources/local/codex/plugins/cache/openai-primary-runtime/documents/26.505.10851/skills/documents/tasks/create_edit.md

@@ -1,47 +0,0 @@
-# Task: Create / edit a DOCX
-
-## Default tool: python-docx
-Use `python-docx` for:
-- paragraphs/runs
-- built-in styles (Title / Heading 1 / Heading 2)
-- tables (structure + cell text + basic formatting)
-- simple headers/footers and margins
-
-## Practical python-docx gotchas
-
-### 1) Header/footer tables require a width
-When adding tables to headers/footers, `add_table` requires an explicit width:
-
-```python
-from docx.shared import Inches
-from docx.enum.text import WD_ALIGN_PARAGRAPH
-
-section = doc.sections[0]
-footer = section.footer
-table = footer.add_table(rows=1, cols=3, width=Inches(6.5))
-# Align text inside each cell
-table.rows[0].cells[0].paragraphs[0].alignment = WD_ALIGN_PARAGRAPH.LEFT
-```
-
-### 2) Fonts can require setting both `run.font.name` and `w:rFonts`
-Some renderers/Word builds don’t respect only `run.font.name`:
-
-```python
-from docx.oxml.ns import qn
-
-run.font.name = "Gill Sans"
-run._element.rPr.rFonts.set(qn("w:ascii"), "Gill Sans")
-run._element.rPr.rFonts.set(qn("w:hAnsi"), "Gill Sans")
-```
-
-### 3) “Clear header paragraph” isn’t always one call
-If you need to replace an existing header paragraph, remove runs (or replace the paragraph XML). Avoid assuming a `clear()` method exists.
-
-### 4) Tracked changes and comments are not first-class
-If the user requests *real* tracked changes or *real* Word comments, plan for OOXML patching (see `ooxml/`).
-
-## After every meaningful batch of edits: render and review
-Use the loop from `tasks/verify_render.md` (DOCX → PNG) to avoid shipping layout defects. (Internally the renderer uses a PDF step; `--emit_pdf` can persist it if needed.)
-
-## Output hygiene
-Keep `/mnt/data` clean: deliverables only unless the user asks for intermediate render artifacts.