@heylemon/lemonade 0.1.8 → 0.1.10

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.1.8",
-  "commit": "afe9f4d0fa565323c39787bae2854ba5905b5a21",
-  "builtAt": "2026-02-21T18:20:37.765Z"
+  "version": "0.1.10",
+  "commit": "091a5fb31c13a8706120e95f8cc1161d21b1d842",
+  "builtAt": "2026-02-21T20:08:01.424Z"
 }

package/dist/canvas-host/a2ui/.bundle.hash

@@ -1 +1 @@
-38125fabd1c2129cedf329e3c20fd69940046e0859a30f6906f3ff0f944a5aaa
+ae5dd78f56173dbfc66b8b6f4a72fb917e3108dcb10745fd17c25536ee4bd709

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heylemon/lemonade",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "AI gateway CLI for Lemon - local AI assistant with integrations",
   "publishConfig": {
     "access": "restricted"

package/skills/docx/SKILL.md

@@ -7,14 +7,30 @@ description: "Create professional, polished documents — reports, memos, propos
 
 Create polished, production-ready documents using docx-js, the clean standards-compliant Node.js library for producing .docx files. This skill writes bespoke code for each request rather than using JSON templates — you have full control over the document API.
 
+## ⚠️ MANDATORY: Post-Processing After Every Build
+
+docx-js has TWO bugs that cause documents to look wrong in Apple Pages and Google Docs. **After generating ANY document, you MUST run BOTH scripts:**
+
+```bash
+# Step 1: Fix table column grids (tables break in Pages without this)
+python scripts/fix_tables.py output.docx
+
+# Step 2: Fix heading styles (headings show wrong colors/fonts in Pages without this)
+python scripts/fix_styles.py output.docx
+```
+
+These are not optional. Without fix_tables.py, tables render as 1-character-wide columns in Pages. Without fix_styles.py, headings appear in default blue instead of your custom colors. Run both immediately after `node create-doc.js`, before delivering the file. The scripts are located in the same skill folder as this SKILL.md.
+
 ## Quick Reference
 
 | Task | Approach | Tool |
 |------|----------|------|
-| **Create new document** | Write docx-js code using Document, Packer, Paragraph, TextRun, Table | Node.js + docx-js |
+| **Create new document** | Write docx-js code, then run both fix scripts | Node.js + docx-js |
 | **Read/analyze existing** | Unzip → read document.xml or use pandoc for content extraction | unzip or pandoc |
 | **Edit existing file** | Unzip → modify XML → repack into .docx | unzip + JSZip |
 | **Validate output** | Check XML, fonts, structure, paragraphs | `python scripts/validate.py` |
+| **Fix tables (MANDATORY)** | Patch tblGrid for cross-platform | `python scripts/fix_tables.py output.docx` |
+| **Fix styles (MANDATORY)** | Patch heading styles for cross-platform | `python scripts/fix_styles.py output.docx` |
 | **Visual QA** | Convert to PDF then to images | soffice + pdftoppm |
 
 ---
@@ -102,30 +118,55 @@ const COLORS = {
 
 ### Creating Headings with Styles
 
-Override built-in heading styles to ensure they appear in TOC. Use `outlineLevel` to control Table of Contents depth:
+**CRITICAL: Use `children` with TextRun, NOT the `run` property.** The `run` property puts formatting in `pPr/rPr` (paragraph default run properties) but the actual `<w:r>` gets no `<w:rPr>`. Word inherits from `pPr/rPr` just fine, but Apple Pages reads from `styles.xml` instead and ignores inline paragraph-level overrides. By using `children` with an explicit `TextRun`, the formatting goes directly on the run itself, which Pages always respects.
 
 ```javascript
+// ✅ CORRECT — formatting on the TextRun (works in Pages)
 new Paragraph({
-  text: "Section Title",
   heading: HeadingLevel.HEADING_1,
-  outlineLevel: 0,  // Appears in TOC
-  style: "Heading1",
-  run: {
-    bold: true,
-    size: TYPOGRAPHY.h1,
-    color: COLORS.primary,
-    font: "Arial"
-  },
-  spacing: { before: 480, after: 160 }  // 12pt before, 4pt after
+  spacing: { before: 480, after: 160 },
+  children: [
+    new TextRun({
+      text: "Section Title",
+      bold: true,
+      size: TYPOGRAPHY.h1,
+      color: COLORS.primary,
+      font: "Arial"
+    })
+  ]
 });
 
+// ❌ WRONG — formatting on `run` property (breaks in Pages)
 new Paragraph({
   text: "Subsection",
-  heading: HeadingLevel.HEADING_2,
-  outlineLevel: 1,
-  style: "Heading2",
-  run: { size: TYPOGRAPHY.h2, color: COLORS.primary },
-  spacing: { before: 360, after: 120 }
+  heading: HeadingLevel.HEADING_1,
+  style: "Heading1",
+  run: { bold: true, size: TYPOGRAPHY.h1, color: COLORS.primary, font: "Arial" },
+  spacing: { before: 480, after: 160 }
+});
+```
+
+Also note: use `italics: true` (with 's'), not `italic: true`. The latter silently does nothing in docx-js.
+
+### Prevent Duplicate Text Rendering (CRITICAL)
+
+**Use exactly one text source per paragraph.** In docx-js, a paragraph can get text from:
+- `text: "..."` on `new Paragraph(...)`, or
+- `children: [new TextRun({ text: "..." })]`
+
+If you set both, the same title/subtitle/date can render twice (common on cover pages).
+
+```javascript
+// ✅ Correct: one source (children only)
+new Paragraph({
+  spacing: { after: 160 },
+  children: [new TextRun({ text: "February 22, 2026", size: 28, color: COLORS.muted })]
+});
+
+// ❌ Wrong: duplicates text (text + children)
+new Paragraph({
+  text: "February 22, 2026",
+  children: [new TextRun({ text: "February 22, 2026", size: 28, color: COLORS.muted })]
 });
 ```
 
@@ -324,7 +365,9 @@ Or use a more sophisticated approach with field codes (requires XML manipulation
 - Set both table width AND individual cell widths in DXA
 - Use `ShadingType.CLEAR` for cell backgrounds
 - Use `HeadingLevel.HEADING_1`, etc., with `outlineLevel` for TOC
-- Override heading styles with explicit `style: "Heading1"` properties
+- Use `children` with TextRun for headings, NOT the `run` property (Pages ignores `run`)
+- Use `italics: true` (with 's'), not `italic: true`
+- Use exactly one text source per paragraph: either `text` OR `children`, never both
 - Set `spacing.before` and `spacing.after` explicitly on headings
 
 **DON'T:**
@@ -336,6 +379,9 @@ Or use a more sophisticated approach with field codes (requires XML manipulation
 - Forget cell width specifications (columns collapse)
 - Use `ShadingType.SOLID` (use CLEAR)
 - Assume A4 page size (always set explicitly to US Letter)
+- Use `run` property on headings (use `children` with TextRun instead — Pages ignores `run`)
+- Use `italic: true` without the 's' (use `italics: true`)
+- Put the same literal content in both `text` and `children` on one Paragraph (duplicates output)
 - Mix font styles — stick to 2 fonts (heading + body)
 
 ---
@@ -427,6 +473,7 @@ The validator checks:
 - Paragraph length (warns if > 500 chars)
 - Empty headings
 - Manual bullet characters (should use List APIs)
+- Obvious cover/title duplication risks (`text` + `children` on same paragraph in generation code)
 
 ### 2. Fix Tables for Cross-Platform (MANDATORY if document contains tables)
 
@@ -444,7 +491,23 @@ This script:
 
 **Always run this after generating any document with tables.** Without it, tables will look correct in Word but break in Pages and Google Docs.
 
-### 3. Visual Check (PDF Conversion)
+### 3. Fix Heading Styles for Cross-Platform (MANDATORY)
+
+docx-js generates default blue heading styles in `styles.xml` regardless of your inline formatting. Word uses inline run properties, but Pages reads `styles.xml` first, causing headings to appear in the wrong color/font/size.
+
+```bash
+python scripts/fix_styles.py report.docx
+```
+
+This script:
+- Reads each heading's actual inline formatting (color, font, size, bold) from the document
+- Patches `styles.xml` heading style definitions to match
+- Adds paragraph spacing to style definitions
+- Overwrites the file in place (or pass a second arg for a new file)
+
+**Always run this after generating any document with headings.** Without it, headings will look correct in Word but show default blue colors in Pages.
+
+### 4. Visual Check (PDF Conversion)
 
 ```bash
 # Convert to PDF
@@ -456,14 +519,17 @@ pdftoppm -jpeg -r 150 report.pdf page
 # View: page-1.jpg, page-2.jpg, etc.
 ```
 
-### 4. Fix & Re-validate
+During this visual pass, explicitly check the title block (title, subtitle, date) for ghosted/double text. If duplicated, inspect the corresponding `new Paragraph(...)` and remove either `text` or `children` so only one text source remains.
+
+### 5. Fix & Re-validate
 
 If the validator reports issues or the PDF looks off:
 1. Fix the docx-js code
 2. Re-run to regenerate .docx
 3. Run `fix_tables.py` again (step 2)
-4. Re-validate with `validate.py`
-5. Re-convert to PDF if visual issues
+4. Run `fix_styles.py` again (step 3)
+5. Re-validate with `validate.py`
+6. Re-convert to PDF if visual issues
 
 Iterate until both validation passes and visual output looks polished.
 

package/skills/docx/references/templates.md

@@ -2,6 +2,17 @@
 
 Each template shows the structure and a docx-js code snippet for that document type.
 
+## Important Implementation Notes
+
+- Prefer the deterministic Python engine (`scripts/create_doc.py`) for production output when possible.
+- If using docx-js directly, use exactly one paragraph text source:
+  - `text: "..."` **or** `children: [new TextRun({ text: "..." })]`
+  - never both on the same `new Paragraph(...)`.
+- Run both post-processors after generation:
+  - `python scripts/fix_tables.py output.docx`
+  - `python scripts/fix_styles.py output.docx`
+- Run `python scripts/validate.py output.docx` before delivery to catch duplicate render patterns early.
+
 ## Report
 
 The most versatile template. Use for analytical, strategic, or informational documents.

package/skills/docx/scripts/fix_styles.py

@@ -0,0 +1,394 @@
+#!/usr/bin/env python3
+"""
+fix_styles.py — Patch styles.xml in a .docx for Apple Pages compatibility.
+
+docx-js generates styles.xml with THREE problems that break Pages rendering:
+
+1. Empty docDefaults — <w:rPrDefault/> and <w:pPrDefault/> with no content.
+   Pages needs proper defaults (font, size, language, paragraph spacing) to
+   correctly interpret inline paragraph properties like w:jc (alignment).
+
+2. Missing Normal style — No default paragraph style is defined. Pages needs
+   a Normal style with w:default="1" as the base for all paragraph rendering.
+   Without it, Pages ignores inline paragraph formatting like center alignment.
+
+3. Wrong heading colors — Heading styles have default blue (#2E74B5) colors
+   regardless of what colors you use in the document. Pages reads styles.xml
+   instead of inline run properties.
+
+This script fixes all three issues by:
+- Adding proper docDefaults with font, size, language, and paragraph spacing
+- Adding a Normal style with w:default="1" if it doesn't exist
+- Reading actual heading formatting from the document and patching styles.xml
+
+Usage:
+    python fix_styles.py input.docx [output.docx]
+
+If output is omitted, the file is modified in place.
+"""
+
+import os
+import shutil
+import sys
+import tempfile
+import zipfile
+from xml.etree import ElementTree as ET
+
+NS = {
+    "w": "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
+    "mc": "http://schemas.openxmlformats.org/markup-compatibility/2006",
+    "r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+}
+
+# Register all namespaces to preserve them on write
+for prefix, uri in NS.items():
+    ET.register_namespace(prefix, uri)
+
+# Register additional namespaces commonly in docx
+EXTRA_NS = {
+    "wpc": "http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas",
+    "o": "urn:schemas-microsoft-com:office:office",
+    "m": "http://schemas.openxmlformats.org/officeDocument/2006/math",
+    "v": "urn:schemas-microsoft-com:vml",
+    "wp14": "http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing",
+    "wp": "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing",
+    "w10": "urn:schemas-microsoft-com:office:word",
+    "w14": "http://schemas.microsoft.com/office/word/2010/wordml",
+    "w15": "http://schemas.microsoft.com/office/word/2012/wordml",
+    "wpg": "http://schemas.microsoft.com/office/word/2010/wordprocessingGroup",
+    "wpi": "http://schemas.microsoft.com/office/word/2010/wordprocessingInk",
+    "wne": "http://schemas.microsoft.com/office/word/2006/wordml",
+    "wps": "http://schemas.microsoft.com/office/word/2010/wordprocessingShape",
+}
+for prefix, uri in EXTRA_NS.items():
+    ET.register_namespace(prefix, uri)
+
+W = NS["w"]
+WNS = f"{{{W}}}"
+
+
+def fix_doc_defaults(root):
+    """
+    Ensure docDefaults has proper rPrDefault and pPrDefault.
+    Pages needs these to correctly resolve inline paragraph properties.
+    """
+    doc_defaults = root.find(f"{WNS}docDefaults")
+    if doc_defaults is None:
+        # Insert docDefaults as first child
+        doc_defaults = ET.SubElement(root, f"{WNS}docDefaults")
+        root.insert(0, doc_defaults)
+
+    fixed = False
+
+    # Fix rPrDefault
+    rpr_default = doc_defaults.find(f"{WNS}rPrDefault")
+    if rpr_default is None:
+        rpr_default = ET.SubElement(doc_defaults, f"{WNS}rPrDefault")
+
+    rpr = rpr_default.find(f"{WNS}rPr")
+    if rpr is None or len(rpr) == 0:
+        # Empty rPrDefault — add proper defaults
+        if rpr is not None:
+            doc_defaults.remove(rpr_default)
+            rpr_default = ET.SubElement(doc_defaults, f"{WNS}rPrDefault")
+
+        rpr = ET.SubElement(rpr_default, f"{WNS}rPr")
+
+        # Default fonts
+        fonts = ET.SubElement(rpr, f"{WNS}rFonts")
+        fonts.set(f"{WNS}asciiTheme", "minorHAnsi")
+        fonts.set(f"{WNS}eastAsiaTheme", "minorEastAsia")
+        fonts.set(f"{WNS}hAnsiTheme", "minorHAnsi")
+        fonts.set(f"{WNS}cstheme", "minorBidi")
+
+        # Default size (11pt = 22 half-points)
+        sz = ET.SubElement(rpr, f"{WNS}sz")
+        sz.set(f"{WNS}val", "22")
+        sz_cs = ET.SubElement(rpr, f"{WNS}szCs")
+        sz_cs.set(f"{WNS}val", "22")
+
+        # Language
+        lang = ET.SubElement(rpr, f"{WNS}lang")
+        lang.set(f"{WNS}val", "en-US")
+        lang.set(f"{WNS}eastAsia", "en-US")
+        lang.set(f"{WNS}bidi", "ar-SA")
+
+        fixed = True
+
+    # Fix pPrDefault
+    ppr_default = doc_defaults.find(f"{WNS}pPrDefault")
+    if ppr_default is None:
+        ppr_default = ET.SubElement(doc_defaults, f"{WNS}pPrDefault")
+
+    ppr = ppr_default.find(f"{WNS}pPr")
+    if ppr is None or len(ppr) == 0:
+        # Empty pPrDefault — add proper defaults
+        if ppr is not None:
+            doc_defaults.remove(ppr_default)
+            ppr_default = ET.SubElement(doc_defaults, f"{WNS}pPrDefault")
+
+        ppr = ET.SubElement(ppr_default, f"{WNS}pPr")
+
+        # Default paragraph spacing (after=200, line=276, lineRule=auto)
+        spacing = ET.SubElement(ppr, f"{WNS}spacing")
+        spacing.set(f"{WNS}after", "200")
+        spacing.set(f"{WNS}line", "276")
+        spacing.set(f"{WNS}lineRule", "auto")
+
+        fixed = True
+
+    return fixed
+
+
+def fix_normal_style(root):
+    """
+    Ensure a proper Normal style exists with w:default="1".
+    Pages needs this as the base paragraph style to correctly resolve
+    inline formatting like center alignment and spacing.
+    """
+    # Check if Normal style already exists
+    for style_el in root.findall(f"{WNS}style"):
+        style_id = style_el.get(f"{WNS}styleId", "")
+        if style_id == "Normal":
+            # Ensure it has w:default="1"
+            if style_el.get(f"{WNS}default") != "1":
+                style_el.set(f"{WNS}default", "1")
+                return True
+            return False
+
+    # Normal style doesn't exist — create it
+    normal = ET.SubElement(root, f"{WNS}style")
+    normal.set(f"{WNS}type", "paragraph")
+    normal.set(f"{WNS}default", "1")
+    normal.set(f"{WNS}styleId", "Normal")
+
+    name = ET.SubElement(normal, f"{WNS}name")
+    name.set(f"{WNS}val", "Normal")
+
+    ET.SubElement(normal, f"{WNS}qFormat")
+
+    # Move it to be the first style (after docDefaults and latentStyles)
+    root.remove(normal)
+    insert_pos = 0
+    for i, child in enumerate(root):
+        tag = child.tag.split("}")[-1] if "}" in child.tag else child.tag
+        if tag in ("docDefaults", "latentStyles"):
+            insert_pos = i + 1
+    root.insert(insert_pos, normal)
+
+    return True
+
+
+def extract_heading_styles_from_document(doc_tree):
+    """
+    Scan document.xml for heading paragraphs and extract their inline formatting.
+    Returns dict: { 'Heading1': { 'color': '6B2D2D', 'sz': '36', ... }, ... }
+    """
+    root = doc_tree.getroot()
+    body = root.find(f".//{WNS}body")
+    if body is None:
+        return {}
+
+    heading_styles = {}
+
+    for para in body.findall(f".//{WNS}p"):
+        p_pr = para.find(f"{WNS}pPr")
+        if p_pr is None:
+            continue
+
+        p_style = p_pr.find(f"{WNS}pStyle")
+        if p_style is None:
+            continue
+        style_id = p_style.get(f"{WNS}val", "")
+        if not style_id.startswith("Heading"):
+            continue
+        if style_id in heading_styles:
+            continue
+
+        fmt = {}
+        # Try inline run properties first (w:r/w:rPr)
+        run = para.find(f"{WNS}r")
+        if run is not None:
+            r_pr = run.find(f"{WNS}rPr")
+            if r_pr is not None:
+                _extract_rpr(r_pr, fmt)
+
+        # Fall back to paragraph default rPr (pPr/rPr)
+        if not fmt:
+            p_rpr = p_pr.find(f"{WNS}rPr")
+            if p_rpr is not None:
+                _extract_rpr(p_rpr, fmt)
+
+        # Extract paragraph spacing
+        spacing = p_pr.find(f"{WNS}spacing")
+        if spacing is not None:
+            before = spacing.get(f"{WNS}before")
+            after = spacing.get(f"{WNS}after")
+            if before:
+                fmt["spacing_before"] = before
+            if after:
+                fmt["spacing_after"] = after
+
+        if fmt:
+            heading_styles[style_id] = fmt
+
+    return heading_styles
+
+
+def _extract_rpr(r_pr, fmt):
+    """Extract formatting properties from a w:rPr element."""
+    color = r_pr.find(f"{WNS}color")
+    if color is not None:
+        fmt["color"] = color.get(f"{WNS}val", "")
+
+    sz = r_pr.find(f"{WNS}sz")
+    if sz is not None:
+        fmt["sz"] = sz.get(f"{WNS}val", "")
+
+    fonts = r_pr.find(f"{WNS}rFonts")
+    if fonts is not None:
+        fmt["font"] = fonts.get(f"{WNS}ascii", "")
+
+    bold = r_pr.find(f"{WNS}b")
+    if bold is not None:
+        fmt["bold"] = True
+
+    italics = r_pr.find(f"{WNS}i")
+    if italics is not None:
+        fmt["italics"] = True
+
+
+def patch_heading_styles(root, heading_styles):
+    """Update heading style definitions with actual formatting from the document."""
+    patched = 0
+
+    for style_el in root.findall(f"{WNS}style"):
+        style_id = style_el.get(f"{WNS}styleId", "")
+        if style_id not in heading_styles:
+            continue
+
+        fmt = heading_styles[style_id]
+
+        # Patch run properties
+        r_pr = style_el.find(f"{WNS}rPr")
+        if r_pr is None:
+            r_pr = ET.SubElement(style_el, f"{WNS}rPr")
+
+        if "color" in fmt:
+            color = r_pr.find(f"{WNS}color")
+            if color is None:
+                color = ET.SubElement(r_pr, f"{WNS}color")
+            color.set(f"{WNS}val", fmt["color"])
+
+        if "sz" in fmt:
+            for tag_name in ["sz", "szCs"]:
+                el = r_pr.find(f"{WNS}{tag_name}")
+                if el is None:
+                    el = ET.SubElement(r_pr, f"{WNS}{tag_name}")
+                el.set(f"{WNS}val", fmt["sz"])
+
+        if "font" in fmt:
+            fonts = r_pr.find(f"{WNS}rFonts")
+            if fonts is None:
+                fonts = ET.SubElement(r_pr, f"{WNS}rFonts")
+            for attr in ["ascii", "hAnsi", "eastAsia", "cs"]:
+                fonts.set(f"{WNS}{attr}", fmt["font"])
+
+        if fmt.get("bold"):
+            if r_pr.find(f"{WNS}b") is None:
+                ET.SubElement(r_pr, f"{WNS}b")
+            if r_pr.find(f"{WNS}bCs") is None:
+                ET.SubElement(r_pr, f"{WNS}bCs")
+
+        if fmt.get("italics"):
+            if r_pr.find(f"{WNS}i") is None:
+                ET.SubElement(r_pr, f"{WNS}i")
+
+        # Patch paragraph spacing
+        if "spacing_before" in fmt or "spacing_after" in fmt:
+            p_pr = style_el.find(f"{WNS}pPr")
+            if p_pr is None:
+                p_pr = ET.SubElement(style_el, f"{WNS}pPr")
+            spacing = p_pr.find(f"{WNS}spacing")
+            if spacing is None:
+                spacing = ET.SubElement(p_pr, f"{WNS}spacing")
+            if "spacing_before" in fmt:
+                spacing.set(f"{WNS}before", fmt["spacing_before"])
+            if "spacing_after" in fmt:
+                spacing.set(f"{WNS}after", fmt["spacing_after"])
+
+        patched += 1
+
+    return patched
+
+
+def fix_styles(input_path, output_path=None):
+    if output_path is None:
+        output_path = input_path
+
+    tmp_dir = tempfile.mkdtemp(prefix="fix_styles_")
+
+    try:
+        extract_dir = os.path.join(tmp_dir, "extracted")
+        with zipfile.ZipFile(input_path, "r") as zf:
+            zf.extractall(extract_dir)
+
+        doc_path = os.path.join(extract_dir, "word", "document.xml")
+        styles_path = os.path.join(extract_dir, "word", "styles.xml")
+
+        if not os.path.exists(doc_path) or not os.path.exists(styles_path):
+            print("Error: Missing document.xml or styles.xml")
+            return
+
+        doc_tree = ET.parse(doc_path)
+        styles_tree = ET.parse(styles_path)
+        styles_root = styles_tree.getroot()
+
+        fixes = []
+
+        # Fix 1: docDefaults
+        if fix_doc_defaults(styles_root):
+            fixes.append("docDefaults")
+
+        # Fix 2: Normal style
+        if fix_normal_style(styles_root):
+            fixes.append("Normal style")
+
+        # Fix 3: Heading styles
+        heading_styles = extract_heading_styles_from_document(doc_tree)
+        if heading_styles:
+            patched = patch_heading_styles(styles_root, heading_styles)
+            if patched:
+                fixes.append(f"{patched} heading style(s)")
+
+        if not fixes:
+            print(f"No fixes needed in {output_path}")
+            return
+
+        # Write back
+        styles_tree.write(styles_path, xml_declaration=True, encoding="UTF-8")
+
+        # Repack
+        tmp_docx = os.path.join(tmp_dir, "output.docx")
+        with zipfile.ZipFile(tmp_docx, "w", zipfile.ZIP_DEFLATED) as zf:
+            for root_dir, _, files in os.walk(extract_dir):
+                for f in files:
+                    full_path = os.path.join(root_dir, f)
+                    arc_name = os.path.relpath(full_path, extract_dir)
+                    zf.write(full_path, arc_name)
+
+        shutil.copy2(tmp_docx, output_path)
+        print(f"Fixed {', '.join(fixes)} in {output_path}")
+
+    finally:
+        shutil.rmtree(tmp_dir, ignore_errors=True)
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Usage: python fix_styles.py input.docx [output.docx]")
+        sys.exit(1)
+
+    input_file = sys.argv[1]
+    output_file = sys.argv[2] if len(sys.argv) > 2 else None
+    fix_styles(input_file, output_file)

package/skills/docx/scripts/fix_tables.py

@@ -76,8 +76,8 @@ def fix_docx(input_path, output_path=None):
     if output_path is None:
         output_path = input_path
 
-    tmp_dir = input_path + '_tmp'
-    os.makedirs(tmp_dir, exist_ok=True)
+    import tempfile
+    tmp_dir = tempfile.mkdtemp(prefix='fix_tables_')
 
     try:
         # Extract

package/skills/docx/scripts/validate.py

@@ -8,6 +8,7 @@ Checks for:
 - Paragraph length and structure
 - Empty headings
 - Manual bullet characters (should use List APIs)
+- Duplicate title/content rendering (same phrase repeated adjacently)
 - Table consistency
 - Page setup
 
@@ -18,6 +19,7 @@ import sys
 import os
 import zipfile
 import xml.etree.ElementTree as ET
+import re
 from pathlib import Path
 
 try:
@@ -90,10 +92,35 @@ def validate_document(docx_path):
 
     # Unicode bullet characters
     bullet_chars = {'•', '◦', '▪', '●', '○', '■', '–', '—', '-', '*'}
+    non_empty_paragraphs = []
+
+    def normalize_text(text):
+        """Normalize visible text for duplicate detection."""
+        # Case-insensitive, collapse whitespace, keep only alnum/space
+        cleaned = re.sub(r"[^a-zA-Z0-9\s]", " ", text.lower())
+        return " ".join(cleaned.split())
+
+    def find_adjacent_repeat_phrase(text, min_words=3, max_words=16):
+        """Detect adjacent repeated phrase in one paragraph.
+
+        Example: "The Great War ... The Great War ..."
+        """
+        words = normalize_text(text).split()
+        if len(words) < min_words * 2:
+            return None
+        upper = min(max_words, len(words) // 2)
+        for size in range(upper, min_words - 1, -1):
+            for i in range(0, len(words) - 2 * size + 1):
+                left = words[i:i + size]
+                right = words[i + size:i + 2 * size]
+                if left == right:
+                    return " ".join(left)
+        return None
 
     for p in doc.paragraphs:
         paragraph_count += 1
         text = p.text.strip()
+        norm_text = normalize_text(text)
 
         # Track empty paragraphs
         if not text:
@@ -102,6 +129,7 @@ def validate_document(docx_path):
             max_consecutive_empty = max(max_consecutive_empty, consecutive_empty)
         else:
             consecutive_empty = 0
+            non_empty_paragraphs.append((paragraph_count, text, norm_text))
 
         # Check headings
         if p.style.name.startswith("Heading"):
@@ -137,6 +165,14 @@ def validate_document(docx_path):
             word_count = len(text.split())
             warnings.append(f"Very long paragraph ({len(text)} chars, {word_count} words): \"{text[:50]}...\" — consider breaking up")
 
+        # Detect duplicated phrase inside the same paragraph
+        if len(text) >= 20:
+            repeated = find_adjacent_repeat_phrase(text)
+            if repeated:
+                issues.append(
+                    f"Possible duplicated text in paragraph {paragraph_count}: repeated phrase \"{repeated[:60]}\""
+                )
+
         # Check for excessive spacing/empty paragraphs
         if len(text) == 0 and paragraph_count > 1:
             # This is tracked separately
@@ -181,6 +217,15 @@ def validate_document(docx_path):
     if paragraph_count < 3:
         warnings.append("Document is very short — consider if this is complete")
 
+    # Detect duplicate consecutive non-empty paragraphs (common in title blocks)
+    for idx in range(len(non_empty_paragraphs) - 1):
+        curr_num, curr_raw, curr_norm = non_empty_paragraphs[idx]
+        next_num, next_raw, next_norm = non_empty_paragraphs[idx + 1]
+        if curr_norm and curr_norm == next_norm:
+            issues.append(
+                f"Consecutive duplicate paragraphs at {curr_num} and {next_num}: \"{curr_raw[:80]}\""
+            )
+
     # ─── Summary info ───
     info.append(f"Paragraphs: {paragraph_count}")
     info.append(f"Headings: {heading_count}")