medsci-skills 4.1.0

package/skills/fill-icmje-coi/scripts/fill_icmje_coi.py

@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+"""
+fill_icmje_coi.py — Batch-fill ICMJE Conflict of Interest Disclosure Forms.
+
+Approach: ICMJE's official `coi_disclosure.docx` uses Content Controls (SDTs).
+python-docx's `cell.text` ignores SDT-wrapped content, so we operate on
+`word/document.xml` directly via zipfile + targeted string replacement.
+
+Template strategy (works because it avoids authoring SDT XML from scratch):
+- Use a previously-filled ICMJE form ("seed template") as the source, where
+  all 13 disclosure items are already marked ☒ + "None" and the final
+  certification is ☒.
+- Clone the seed per-author and replace only three fields:
+    1. Date  (e.g. "April 12, 2026" → "April 20, 2026")
+    2. Name  (seed author full name → target author full name)
+    3. Title (seed manuscript title → target manuscript title)
+
+Usage (Python API):
+    from fill_icmje_coi import fill_icmje_forms
+    fill_icmje_forms(
+        seed_docx=Path("/path/to/icmje_seed_filled.docx"),
+        seed_name="Placeholder Author",
+        seed_title="Placeholder Manuscript Title",
+        seed_date="January 1, 2000",
+        new_title="Your Manuscript Title",
+        new_date="Month D, YYYY",
+        authors=[(1, "Author One"), (2, "Author Two"), ...],
+        out_dir=Path("submission/{journal}/icmje_forms"),
+    )
+
+CLI:
+    fill_icmje_coi.py --seed <docx> --seed-name "X" --seed-title "Y" \
+        --seed-date "April 12, 2026" --new-title "Z" \
+        --new-date "April 20, 2026" --out-dir <dir> \
+        --authors '[[1,"A"],[2,"B"]]'
+
+Safety:
+- Only a literal-string replacement in word/document.xml; no SDT surgery.
+- Seed-value collisions inside other document text are unlikely but verify
+  by dumping the seed XML first (see test section in source).
+- All other .docx parts (styles.xml, rels, etc.) copied byte-identically.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import shutil
+import sys
+import zipfile
+from pathlib import Path
+from typing import Iterable
+
+
+DOCUMENT_XML = "word/document.xml"
+
+
+def _replace_in_zip(src: Path, dst: Path, replacements: dict[str, str]) -> None:
+    """Copy src → dst, replacing text in word/document.xml per replacements."""
+    with zipfile.ZipFile(src, "r") as zin, zipfile.ZipFile(dst, "w", zipfile.ZIP_DEFLATED) as zout:
+        for item in zin.infolist():
+            data = zin.read(item.filename)
+            if item.filename == DOCUMENT_XML:
+                text = data.decode("utf-8")
+                for old, new in replacements.items():
+                    if old and old not in text:
+                        raise ValueError(
+                            f"[{dst.name}] seed string not found in document.xml: {old!r}\n"
+                            f"Dump with: unzip -p <seed.docx> word/document.xml | grep -o '<w:t[^>]*>[^<]*</w:t>'"
+                        )
+                    if old:
+                        # XML-escape new value (& < > " ')
+                        escaped = (new.replace("&", "&amp;")
+                                      .replace("<", "&lt;")
+                                      .replace(">", "&gt;"))
+                        text = text.replace(old, escaped)
+                data = text.encode("utf-8")
+            zout.writestr(item, data)
+
+
+def fill_icmje_forms(
+    seed_docx: Path,
+    seed_name: str,
+    seed_title: str,
+    seed_date: str,
+    new_title: str,
+    new_date: str,
+    authors: Iterable[tuple[int, str]],
+    out_dir: Path,
+    filename_template: str = "ICMJE_COI_{idx:02d}_{slug}.docx",
+) -> list[Path]:
+    """Generate one filled docx per author. Returns list of written paths."""
+    out_dir.mkdir(parents=True, exist_ok=True)
+    written: list[Path] = []
+    for idx, author_name in authors:
+        slug = re.sub(r"\s+", "_", author_name.strip())
+        out_path = out_dir / filename_template.format(idx=idx, slug=slug)
+        replacements = {
+            seed_title: new_title,
+            seed_date: new_date,
+            seed_name: author_name,
+        }
+        _replace_in_zip(seed_docx, out_path, replacements)
+        written.append(out_path)
+        print(f"  ✓ {out_path.name}  ({author_name})")
+    return written
+
+
+def main() -> int:
+    p = argparse.ArgumentParser(description=__doc__.split("\n\n")[0])
+    p.add_argument("--seed", type=Path, required=True, help="Filled ICMJE docx to clone")
+    p.add_argument("--seed-name", required=True)
+    p.add_argument("--seed-title", required=True)
+    p.add_argument("--seed-date", required=True)
+    p.add_argument("--new-title", required=True)
+    p.add_argument("--new-date", required=True)
+    p.add_argument("--out-dir", type=Path, required=True)
+    p.add_argument("--authors", required=True, help='JSON list: [[1,"Full Name"],...]')
+    args = p.parse_args()
+
+    authors = [tuple(x) for x in json.loads(args.authors)]
+    print(f"Seed: {args.seed}")
+    print(f"Output dir: {args.out_dir}")
+    print(f"Authors: {len(authors)}")
+    fill_icmje_forms(
+        seed_docx=args.seed,
+        seed_name=args.seed_name,
+        seed_title=args.seed_title,
+        seed_date=args.seed_date,
+        new_title=args.new_title,
+        new_date=args.new_date,
+        authors=authors,
+        out_dir=args.out_dir,
+    )
+    print(f"Done. {len(authors)} forms written to {args.out_dir}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/skills/fill-icmje-coi/skill.yml

@@ -0,0 +1,35 @@
+schema_version: 2
+name: fill-icmje-coi
+layer: A
+owner_domain: form_filling
+
+when_to_use: "Batch-generate per-author ICMJE COI disclosure forms from a synthetic seed, pre-filled as 'None' with date/name/title replaced."
+when_NOT_to_use: "Filling an IRB or institutional Word form (use fill-protocol)."
+
+inputs:
+  - "author list"
+  - "manuscript title"
+  - "date"
+outputs:
+  - "per-author coi_disclosure.docx files"
+deterministic_scripts:
+  - scripts/fill_icmje_coi.py
+side_effects:
+  - writes_docx_forms
+downstream_consumers:
+  - none
+forbidden_actions:
+  - alter_checkboxes_or_disclosure_items
+  - use_a_seed_containing_real_author_pii
+
+# v2.1 quality card
+purpose: "Clone the ICMJE COI form per author with date/name/title filled, defaulting all 13 items to 'None' for the no-conflict common case."
+safety_boundaries:
+  - "Only date, name, and manuscript title are substituted; the 13 items and certification come from the seed unchanged."
+  - "Ships a synthetic PII-free seed; never commits a seed with real author PII."
+known_limitations:
+  - "Authors with real disclosures must edit their form in Word; the skill cannot infer conflicts."
+  - "A blank ICMJE template cannot be used as the seed (the safety check requires the pre-filled 'None' strings)."
+validation_commands:
+  - "verify each output: 14 checked boxes, 13 'None', no seed-placeholder leakage"
+evidence_surface: bundled_script

package/skills/fill-protocol/SKILL.md

@@ -0,0 +1,248 @@
+---
+name: fill-protocol
+description: >
+  Fill institutional Word form templates (.doc/.docx) for IRB protocols, ethics
+  applications, grant proposals, and other structured research documents while
+  preserving the original styles, table layouts, fonts, and page geometry. Pairs
+  with write-protocol — write-protocol drafts the scientific content, fill-protocol
+  renders it into the institutional template. Korean-aware (CJK eastAsia font
+  enforcement, table cantSplit) but works for any language template.
+triggers: fill protocol, fill template, fill IRB form, IRB template, ethics template, grant template, 양식 채우기, 연구계획서 작성, 신청서 작성, 정부 양식, 병원 양식, 워드 템플릿
+tools: Read, Write, Edit, Bash, Grep, Glob
+model: inherit
+---
+
+# Fill-Protocol Skill
+
+You are helping a researcher populate an institutional Word form (IRB protocol,
+ethics application, grant proposal, etc.) without breaking the original document
+formatting. This skill is the formatting counterpart to `write-protocol`: where
+`write-protocol` drafts content, `fill-protocol` lays that content into the
+institutional template.
+
+## Why This Skill Exists
+
+Recreating institutional forms from scratch with `python-docx` reliably destroys
+table layouts, page breaks, and font consistency. The only safe approach is to
+**open the existing template** and replace cell/paragraph text in place. This
+skill enforces that pattern.
+
+## Core Principles (Do Not Violate)
+
+1. **Open the existing template — never create from scratch.** Use
+   `Document(template_path)`, not `Document()`.
+2. **Convert .doc → .docx via LibreOffice headless** before any editing.
+   `pandoc -f doc` is not supported; `textutil` corrupts table structure.
+3. **Match cells by left-label text**, not row/column coordinates. Templates
+   evolve and coordinate matching breaks silently.
+4. **Apply `cantSplit` to every filled row** so a row never breaks across pages.
+5. **For CJK languages, set the `eastAsia` font attribute**, not just
+   `run.font.name`. Hangul/Kanji/Hanzi will render in fallback fonts otherwise.
+6. **Validate** every fill operation: report unmatched labels, count empty cells,
+   and surface mismatches before saving.
+
+## Dependencies
+
+If the template is already `.docx`, **LibreOffice is not required** — only the
+three Python packages below. LibreOffice is needed only when the template is a
+legacy `.doc` and must be converted first.
+
+```bash
+# Python libraries (always required)
+pip install --user docxtpl python-docx pyyaml
+
+# LibreOffice (only for legacy .doc input; ~700 MB on macOS)
+brew install --cask libreoffice              # macOS
+sudo apt-get install -y libreoffice           # Debian/Ubuntu
+sudo dnf install -y libreoffice               # Fedora
+sudo pacman -S --needed libreoffice-fresh     # Arch
+```
+
+### Bundled setup script
+
+The skill ships a `setup.sh` that detects what is missing and installs only
+those parts, with a confirmation prompt before each step:
+
+```bash
+bash setup.sh check     # report what's installed (read-only)
+bash setup.sh install   # install missing pieces (asks before each)
+```
+
+### Auto-install behavior (for Claude as the caller)
+
+When invoking this skill on behalf of a user:
+
+1. **Before calling `doc_to_docx.py`**, run `bash setup.sh check`. If
+   LibreOffice is missing, **ask the user** before installing — the cask is
+   ~700 MB and proceeding silently is unfriendly.
+2. **Skip LibreOffice entirely** if the template is already `.docx`. Only
+   surface the install prompt when a `.doc` is encountered.
+3. **Never** pass `--yes` to `setup.sh install` unless the user has explicitly
+   authorized unattended installation in this session.
+4. If the user declines installation, fall back to asking them to convert
+   the `.doc` manually (open in Word/LibreOffice/Pages → Save As → .docx) and
+   then re-run with the converted file.
+
+## Workflow
+
+### Step 1 — Convert legacy .doc to .docx (if needed)
+
+```bash
+python scripts/doc_to_docx.py path/to/template.doc path/to/template.docx
+```
+
+### Step 2 — Inspect the template structure
+
+```bash
+python scripts/inspect_template.py path/to/template.docx
+```
+
+This lists every table, every cell (with row/column coordinates and content
+preview), and every top-level paragraph. Use this output to identify the labels
+you will match against in your YAML content file.
+
+### Step 3 — Author a content YAML
+
+The YAML supports three fill modes. All keys are optional.
+
+```yaml
+protections:
+  korean_font: "맑은 고딕"   # CJK font (set to "Noto Sans CJK KR", "SimSun",
+                              # "MS Mincho", etc. for other locales)
+  cant_split: true            # Apply <w:cantSplit/> to every filled row
+
+  # Readability options (see "Readability" section below for full semantics)
+  blank_between_paragraphs: true            # default true — Enter between \n\n chunks
+  blank_around_section_header: true         # default true — Enter above/below filled sections
+  blank_around_all_section_headers: false   # default false — opt-in; also touches untouched sections
+
+# Mode 1 — table key/value (left-label cell → right value cell)
+table_kv:
+  "Study Title": "Multi-center prospective validation of ..."
+  "Principal Investigator": "Last, First (Department)"
+  "연구 목적": "본 연구는 ..."
+
+# Mode 2 — section replacement (find numbered header, replace until next header)
+section_replace:
+  "1. Background":
+    "Hepatocellular carcinoma is the third leading cause of ..."
+  "4. 연구 배경 및 이론적 근거":
+    "..."
+
+# Mode 3 — single paragraph in-place text replacement
+paragraph_replace:
+  "Title:":
+    "Title: Multi-center prospective validation of ..."
+```
+
+### Readability — three blank-line knobs
+
+All blank paragraphs inserted by these options use a forced single-line height
+(`<w:spacing w:line="240" w:before="0" w:after="0"/>`) so the gap is exactly
+one body-text line — never inflates the document's apparent line spacing.
+
+| Option | Default | What it does | When to flip |
+|---|---|---|---|
+| `blank_between_paragraphs` | `true` | Inserts a blank line between every `\n\n`-split chunk inside `section_replace` | Disable only for forms where every line must be packed tight |
+| `blank_around_section_header` | `true` | Wraps each header that you `section_replace` with a blank above and a blank below | Disable when the template style already adds visual gaps via `space_before/after` |
+| `blank_around_all_section_headers` | `false` | After all fills, scans every numbered header (`\d+\.\s+`) — including ones you didn't replace — and adds blank lines around them | Enable when uniform readability matters more than form fidelity. **Default off because IRB / public-document submissions favor template fidelity over visual consistency** (page count stability, boilerplate untouched, reviewer-expected layout) |
+| `normalize_page_breaks` | `true` | On save, converts dangling empty paragraphs whose sole content is `<w:br w:type="page"/>` into a `<w:pageBreakBefore/>` attribute on the next content paragraph. Prevents visible blank pages when the preceding content (e.g. an abstract table) grows or shrinks and pushes the empty paragraph onto a page of its own, causing the break to land one page later. | Disable only if your template intentionally relies on the empty-paragraph-as-separator pattern for spacing |
+
+The third option exists because `section_replace` only touches sections you
+list in the YAML. If a template has 18 numbered sections and you only fill 12,
+the other 6 stay tight against their content — visually inconsistent. Turn the
+opt-in on for documents where you'd rather the consistency than the fidelity.
+
+### Step 4 — Run the fill
+
+```bash
+python scripts/fill_form.py \
+  --template path/to/template.docx \
+  --content  content.yaml \
+  --output   path/to/filled.docx
+```
+
+The CLI prints `[OK]` / `[MISS]` for every fill operation and a summary at the
+end. Investigate any `[MISS]` before submitting.
+
+### Step 5 — Visual verification
+
+```bash
+soffice --headless --convert-to pdf path/to/filled.docx
+```
+
+Open the PDF and visually confirm: page count is sensible, no table row was
+split across pages, no font fell back to Times New Roman, all required fields
+are populated.
+
+## Python API
+
+```python
+from fill_form import FormFiller
+
+filler = FormFiller("template.docx", korean_font="맑은 고딕")
+
+# Fill table cells
+filler.fill_table_kv("Study Title", "...")
+filler.fill_table_kv("연구 목적", "...")
+
+# Replace section content (header to next header)
+filler.replace_paragraphs_after("4. Background", new_content)
+
+# Replace a single paragraph
+filler.replace_paragraph_matching("Title:", "Title: ...")
+
+# Validate and save
+warnings = filler.validate()
+for w in warnings:
+    print(w)
+filler.save("filled.docx")
+```
+
+## Anti-Patterns (Do Not Do)
+
+| Anti-pattern | Consequence |
+|---|---|
+| `Document()` then rebuild table | Loss of header logo, custom margins, footer placeholders, and page numbering |
+| `pandoc -f doc -t docx` | "Unknown input format doc" — pandoc does not parse .doc |
+| `textutil -convert docx` | Table cell merging is dropped or corrupted |
+| `cell.text = "value"` (single assignment) | Run-level styles (bold, color, eastAsia font) are erased |
+| Coordinate-based matching `table.cell(2, 1)` | Silent breakage when the template adds or reorders rows |
+| `run.font.name` alone for Hangul | Hangul characters render in the default Western font |
+
+## Companion Skills
+
+- `write-protocol` — drafts the scientific content (Background, Study Design,
+  Sample Size, Statistical Plan) that `fill-protocol` then renders into the form
+- `hwp-pipeline` — converts Korean Hangul .hwp / .hwpx files; chain it before
+  `fill-protocol` when the institutional form is distributed in HWP format
+- `check-reporting` — validates that the filled protocol satisfies CONSORT /
+  STARD / TRIPOD / CLAIM checklists before submission
+- `calc-sample-size` — produces the sample size text that `fill-protocol` slots
+  into the corresponding section
+
+## Files
+
+- `scripts/doc_to_docx.py` — LibreOffice headless wrapper for .doc → .docx
+- `scripts/inspect_template.py` — reports tables, cells, and paragraphs
+- `scripts/fill_form.py` — the `FormFiller` library and CLI entry point
+- `examples/` — worked examples for IRB, ethics waiver, and grant templates
+- `references/best_practices.md` — formatting notes (cantSplit, eastAsia,
+  multi-line cell text)
+
+## Known Limitations
+
+- **HWP / HWPX input is not handled directly** — chain with `hwp-pipeline` to
+  convert HWP → HWPX → DOCX first.
+- **Merged cells**: filling a label cell that participates in a vertical merge
+  may overwrite the merged region's content. Test on a copy first.
+- **Embedded form fields** (Word's content controls): not yet supported. Plain
+  paragraph and table cell content only.
+- **Right-to-left scripts** (Arabic, Hebrew): untested.
+
+## Anti-Hallucination
+
+- **Never fabricate references.** All citations must be verified via `/search-lit` with confirmed DOI or PMID. Mark unverified references as `[UNVERIFIED - NEEDS MANUAL CHECK]`.
+- **Never invent clinical definitions, diagnostic criteria, or guideline recommendations.** If uncertain, flag with `[VERIFY]` and ask the user.
+- **Never fabricate numerical results** — compliance percentages, scores, effect sizes, or sample sizes must come from actual data or analysis output.
+- If a reporting guideline item, journal policy, or clinical standard is uncertain, state the uncertainty rather than guessing.

package/skills/fill-protocol/examples/example_irb_template.yaml

@@ -0,0 +1,53 @@
+# Example content file for fill-protocol
+# Adapt the labels to match your institution's IRB template exactly
+# (run `inspect_template.py` first to see the actual cell labels)
+
+protections:
+  korean_font: "맑은 고딕"   # Use "Noto Sans CJK KR" on Linux, "Apple SD Gothic Neo" on macOS Apple-default
+  cant_split: true
+
+# Mode 1: ABSTRACT-style key/value table (most institutional IRB forms)
+table_kv:
+  "Study Title": >
+    Multi-center prospective validation of [intervention] for [population]
+  "Principal Investigator": "Family-Name, Given-Name (Department, Institution)"
+  "Study Design": >
+    Prospective, multi-center, single-arm validation cohort with [comparator]
+    as historical control. Primary endpoint assessed at [timepoint].
+  "Study Period": "From IRB approval through [YYYY-MM-DD] (~ X years)"
+  "Target Enrollment": "N = X (this institution: n = Y)"
+  "Inclusion Criteria": |
+    All of the following:
+    1. Age ≥ 19 years
+    2. [Disease] confirmed by [reference standard] between [date] and [date]
+    3. [Imaging modality] with [protocol requirement]
+  "Exclusion Criteria": |
+    Any of the following:
+    1. [Image quality criterion fails]
+    2. [Co-existing disease that confounds]
+    3. Prior [intervention that alters baseline]
+  "Sample Size Justification": >
+    [Insert output of /calc-sample-size here, or describe pilot/feasibility framing]
+
+# Mode 2: Long-form numbered sections in body text
+section_replace:
+  "1. Study Title": >
+    English: ...
+    Korean (국문): ...
+
+  "4. Background and Rationale":
+    "..."  # Insert output of /write-protocol Background section
+
+  "5. Study Objectives":
+    "..."  # Insert output of /write-protocol Objectives section
+
+  "12. Statistical Analysis Plan":
+    "..."  # Insert output of /write-protocol + /analyze-stats Statistical Plan
+
+  "18. References":
+    "..."  # Insert verified references from /search-lit
+
+# Mode 3: Single-paragraph in-place text replacement (e.g., the title line)
+paragraph_replace:
+  "Title:":
+    "Title: Multi-center prospective validation of ..."

package/skills/fill-protocol/references/best_practices.md

@@ -0,0 +1,121 @@
+# fill-protocol — Best Practices Reference
+
+## CJK Font Setting (mandatory for Korean / Japanese / Chinese)
+
+`run.font.name = "맑은 고딕"` alone does **not** apply to Hangul characters in
+docx output. Word and LibreOffice route CJK glyphs through the `eastAsia`
+font slot, which lives in `<w:rPr><w:rFonts w:eastAsia="..."/>`. The skill
+sets all four font slots (`ascii`, `hAnsi`, `cs`, `eastAsia`) to the same
+font name to guarantee consistent rendering.
+
+### Recommended fonts by platform
+
+| Platform | CJK font that always exists |
+|---|---|
+| Windows | 맑은 고딕 (Malgun Gothic) |
+| macOS | Apple SD Gothic Neo |
+| Linux | Noto Sans CJK KR |
+
+If the document will be opened on multiple platforms, embed the font in the
+.docx (Word: File → Options → Save → Embed fonts in the file) or stick to
+fonts that exist everywhere (Noto family).
+
+## Table Row Page-Break Prevention (`cantSplit`)
+
+Korean institutional IRB tables routinely have multi-line cells (e.g.
+inclusion/exclusion criteria with 5–10 items). Without `cantSplit`, a row
+can break across pages and the label cell ends up orphaned on the previous
+page.
+
+The XML insertion looks like:
+
+```xml
+<w:tr>
+  <w:trPr>
+    <w:cantSplit/>           <!-- this line is added by the skill -->
+  </w:trPr>
+  ...
+</w:tr>
+```
+
+The skill applies this automatically to every row that gets filled.
+You can also pre-set this in Word: select the row → Layout → Properties →
+Row → uncheck "Allow row to break across pages".
+
+## Multi-line Cell Content
+
+YAML `|` (literal block) and `>` (folded block) both produce strings with
+embedded newlines. `fill-protocol` splits on `\n` and writes each line as a
+separate paragraph in the cell, cloning the first paragraph's `pPr` so
+indentation, line spacing, and alignment are preserved.
+
+```yaml
+"Inclusion Criteria": |
+  All of the following:
+  1. Age ≥ 19 years
+  2. Confirmed diagnosis ...
+  3. Imaging within 30 days
+```
+
+If you want bullets (•) instead of numbers, type them literally in the
+YAML — Word formatting is preserved at the run level, but list numbering
+markers are not auto-generated.
+
+## Label Matching
+
+The skill normalizes whitespace (including newlines) before comparing
+cell content to the YAML key. So a cell labeled
+
+```
+연구대상자
+정보
+```
+
+matches the YAML key `"연구대상자 정보"` (with a space). Confirm exact
+labels via `inspect_template.py` — institutional templates often have
+trailing spaces, half-width vs. full-width parentheses, or zero-width
+characters that are invisible in Word but break exact-match.
+
+## Section Header Matching
+
+`section_replace` finds a paragraph whose text equals the YAML key, then
+replaces every paragraph from there until the next paragraph that starts
+with `\d+\.\s+` (e.g. "1. ", "12. "). This is robust across templates
+that re-number sections, but assumes numbered headers. For non-numbered
+templates, pass `stop_pattern` to `replace_paragraphs_after()` directly
+in Python.
+
+## Merged Cells
+
+`python-docx` returns the same `_Cell` object for cells that participate
+in a merge (horizontal or vertical). Filling such a cell once propagates
+the content. The skill detects this via `id(cell._tc)` and skips
+duplicates within a row, so vertical-merge label cells won't be filled
+multiple times.
+
+## Validation Before Submission
+
+Always run the visual check:
+
+```bash
+soffice --headless --convert-to pdf filled.docx
+```
+
+Look for:
+
+1. Page count is roughly equal to the original template (±20% is normal,
+   ±50% suggests content overflow or section deletion).
+2. No empty cells in mandatory fields.
+3. Footer / page number formatting unchanged.
+4. CJK characters rendering correctly (not boxes, not Times New Roman
+   substitution).
+5. Tables not broken across pages mid-row.
+
+## When This Skill Is Not the Right Tool
+
+- **HWP / HWPX input**: chain with `hwp-pipeline` first (HWP → HWPX → DOCX)
+- **PDF form filling**: use the `pdf` skill or a dedicated PDF-form library
+- **Free-form research writing**: use `write-paper` or `write-protocol`
+- **Slides / presentations**: use `generate-pptx`
+- **Templates with Word "content controls"** (interactive form fields): not
+  yet supported by this skill