@kortix/sandbox 0.4.1

package/opencode/skills/KORTIX-deep-research/SKILL.md

@@ -0,0 +1,278 @@
+---
+name: kortix-deep-research
+description: "Deep research agent skill. Use when the user needs thorough, scientific, truth-seeking research on any topic -- investigating claims, finding primary sources, synthesizing evidence, producing cited reports. Triggers on: 'research this', 'investigate', 'deep dive', 'find sources', 'what does the evidence say', 'literature review', 'fact check', 'analyze the research on', any request requiring multi-source investigation with citations."
+---
+
+# Deep Research
+
+Systematic, evidence-based research that produces cited, source-backed reports. Uses the **filesystem as working memory** -- scraped content, extracted notes, and source metadata are saved to disk rather than held in context. This keeps the context window lean and makes research resumable, searchable, and reusable.
+
+## Architecture
+
+```
+research/{topic-slug}/
+  plan.md                    # Research plan with sub-questions
+  sources-index.md           # URL registry: what's been scraped, metadata
+  sources/                   # Raw scraped content (one file per source)
+    001-source-slug.md
+    002-source-slug.md
+    ...
+  notes/                     # Extracted findings per sub-question
+    question-1.md
+    question-2.md
+    ...
+  report.md                  # Final compiled report
+```
+
+**Core principle:** Write to disk aggressively, read back selectively. Never hold raw scraped content in context longer than it takes to extract findings. The LLM context should contain only the current working set -- not the entire research corpus.
+
+## Research Parameters
+
+- **Breadth** (default: 3): Parallel search queries per sub-question. Range: 2-6.
+- **Depth** (default: 2): Recursive deepening rounds. Range: 1-4.
+
+Estimate: breadth=3, depth=2 -> ~12-20 web searches, ~8-15 pages read, 3-8 minute runtime.
+
+For quick fact-checks: breadth=2, depth=1.
+For exhaustive reviews: breadth=5, depth=3.
+
+## Step-by-Step Workflow
+
+### Phase 0: Initialize
+
+1. **Create the research directory:**
+   ```bash
+   mkdir -p research/{topic-slug}/sources research/{topic-slug}/notes
+   ```
+
+2. **Search local filesystem first.** Before any web search, check if relevant content already exists:
+   - Past research in `workspace/.kortix/research/` and `workspace/.kortix/memory/`
+   - Relevant files in the working directory or project
+    - Use `grep`, `glob`, or semantic search (`lss`) as appropriate for the task
+   - If prior research exists on this topic, read it and build on it -- don't start from scratch
+
+3. **Initialize `sources-index.md`:**
+   ```markdown
+   # Sources Index
+   
+   | # | URL | Title | Date | Type | Credibility | File |
+   |---|-----|-------|------|------|-------------|------|
+   ```
+
+### Phase 1: Planning
+
+1. Analyze the query. Identify:
+   - Core research question(s)
+   - Required evidence types (empirical data, expert opinion, primary sources, statistics)
+   - Potential biases to watch for
+
+2. Decompose into 2-5 independently researchable sub-questions.
+
+3. Write `plan.md` with the sub-questions, search strategy, and scope decisions.
+
+4. Create a todo list tracking each sub-question.
+
+### Phase 2: Search-Read-Extract Loop
+
+For each sub-question, execute this loop:
+
+#### 2a. Generate Search Queries
+
+Generate `breadth` distinct queries. Vary:
+- Phrasing (synonyms, technical vs. lay terms)
+- Angle (supporting evidence, counter-evidence, meta-analyses)
+- Source type (academic `site:scholar.google.com`, government `site:gov`, news, industry)
+- Recency (add year filters for time-sensitive topics)
+
+**Batch search with `search_depth: "advanced"`:**
+```
+web-search("query1 ||| query2 ||| query3", search_depth="advanced")
+```
+
+#### 2b. Read and Extract
+
+For each promising search result:
+
+1. **Check `sources-index.md` first.** If the URL is already scraped, skip it. Do not re-scrape pages already processed in this session.
+
+2. **Scrape the page.** Batch URLs for efficiency:
+   ```
+   scrape-webpage("url1, url2, url3")
+   ```
+
+3. **Save raw content to disk immediately:**
+   ```bash
+   # Write scraped content to sources/NNN-slug.md
+   ```
+   Include a header with the URL, title, and scrape date. This gets the raw content out of your context.
+
+4. **Extract key findings** from the scraped content and append to `notes/question-N.md`:
+   - Key claims and findings (with brief quotes when important)
+   - Data points: numbers, statistics, dates
+   - The source number (for citation mapping later)
+   - Methodology notes if relevant (sample size, study design)
+
+5. **Update `sources-index.md`** with the new source entry:
+   ```
+   | 003 | https://example.com/article | Article Title | 2025-06-15 | news | medium | sources/003-article-title.md |
+   ```
+
+6. **Free your context.** After extracting findings and saving to disk, you do not need to retain the raw scraped content. Move on to the next source.
+
+#### 2c. Deepen (Recursive)
+
+After processing results for a sub-question:
+
+1. **Read `notes/question-N.md`** to assess coverage.
+2. Identify gaps: what remains unanswered? What claims lack corroboration?
+3. Generate follow-up questions based on findings.
+4. If `depth > 0`: recurse with follow-up questions at `depth - 1` and `ceil(breadth / 2)`.
+5. If `depth == 0`: stop, move to next sub-question.
+
+### Phase 3: Synthesis
+
+After all sub-questions are researched:
+
+1. **Read all `notes/*.md` files** (not raw sources -- the notes are already distilled).
+2. **Cross-reference claims** -- flag where sources agree vs. contradict.
+3. **Resolve contradictions** by source quality:
+   - Peer-reviewed > government data > industry reports > news > blogs
+   - Meta-analyses > individual studies
+   - Multiple independent sources > single source
+4. **Identify consensus vs. uncertainty.** Be explicit about what is well-established vs. debated vs. unknown.
+5. **Check for bias:** Did search results skew toward one viewpoint? Are key perspectives missing?
+
+### Phase 4: Report Generation
+
+Compile `report.md` using findings from notes and metadata from `sources-index.md`.
+
+```markdown
+# [Research Title]
+
+## Executive Summary
+[2-3 paragraph overview of key findings and conclusions]
+
+## Key Findings
+
+### [Finding 1 Title]
+[Discussion with inline citations [1][2]]
+
+### [Finding 2 Title]
+[Discussion with inline citations [3][4]]
+
+## Analysis
+[Cross-cutting patterns, contradictions, consensus areas]
+
+## Limitations & Caveats
+[What this research couldn't determine, methodological limitations]
+
+## Conclusions
+[Evidence-based conclusions with confidence levels]
+
+## Sources
+
+[1] Author (Date). "Title." *Publication*. URL
+[2] Author (Date). "Title." *Publication*. URL
+```
+
+**Build citations from `sources-index.md`** at report time. During the search phase, you only needed to track `{url, title, source_number}`. Now format the full bibliography by reading back source metadata from the index and source files as needed.
+
+### Phase 5: Finalize
+
+1. Save `report.md` in the research directory.
+2. Copy the report to `workspace/.kortix/memory/research-{topic-slug}.md` for long-term memory.
+3. Report to user: main conclusions (2-3 sentences), number of sources, confidence levels, file path.
+
+## Citation Rules
+
+1. **Every factual claim must have a citation.** No uncited assertions of fact.
+2. **Use numbered inline citations** `[1]`, `[2]` that map to the Sources section.
+3. **Never fabricate sources.** Every URL in Sources must be a real page you actually visited and read.
+4. **Quote directly** when the exact wording matters. Use `> blockquote` for direct quotes.
+5. **Distinguish levels of evidence:**
+   - "Studies show..." (cite the studies)
+   - "According to [Source]..." (single source, acknowledge it)
+   - "The evidence suggests..." (multiple corroborating sources)
+   - "It remains debated whether..." (conflicting evidence)
+6. **Date every source.** If no date is found, write "(n.d.)".
+7. **Note source type** in the bibliography: academic paper, government report, news article, blog post, etc.
+
+## Scientific Rigor Standards
+
+- **Falsifiability:** Actively search for counter-evidence. Don't just confirm priors.
+- **Replication:** A claim supported by multiple independent sources is stronger than one from a single source.
+- **Recency awareness:** Newer isn't always better. Note when older foundational work is more relevant.
+- **Correlation vs. causation:** Flag when sources conflate the two.
+- **Sample size and methodology:** Note these for empirical claims.
+- **Conflicts of interest:** Note when a source has a stake in its conclusions.
+
+## Tool Usage Patterns
+
+### Search (always use search_depth "advanced" for deep research)
+```
+web-search("topic aspect1 ||| topic aspect2 ||| topic counter-evidence", search_depth="advanced")
+```
+
+### Scrape (batch URLs)
+```
+scrape-webpage("https://source1.com/article, https://source2.com/study")
+```
+
+### Save scraped content to disk
+```bash
+# After scraping, immediately write to file and extract findings
+# This is critical -- do not hold raw scraped content in context
+```
+
+### Academic Paper Search (OpenAlex)
+
+Load the `kortix-paper-search` skill for full API reference. Quick patterns:
+
+```bash
+# Find highly-cited papers on a topic
+curl -s "https://api.openalex.org/works?search=topic+keywords&filter=cited_by_count:>50,type:article,has_abstract:true&sort=cited_by_count:desc&per_page=15&select=id,display_name,publication_year,cited_by_count,doi,authorships,abstract_inverted_index&mailto=agent@kortix.ai"
+
+# Find recent preprints
+curl -s "https://api.openalex.org/works?search=topic&filter=type:preprint,publication_year:2025&sort=publication_date:desc&per_page=10&mailto=agent@kortix.ai"
+
+# Find review/survey papers
+curl -s "https://api.openalex.org/works?search=topic&filter=type:review,cited_by_count:>20&sort=cited_by_count:desc&per_page=10&mailto=agent@kortix.ai"
+
+# Follow citation chains: who cites a seminal paper?
+curl -s "https://api.openalex.org/works?filter=cites:WORK_ID&sort=cited_by_count:desc&per_page=10&mailto=agent@kortix.ai"
+```
+
+Save paper metadata to `sources-index.md` and raw API responses to `sources/` for later processing.
+
+### Web Source Hunting
+```
+web-search("topic site:scholar.google.com ||| topic site:arxiv.org ||| topic systematic review OR meta-analysis", search_depth="advanced")
+```
+
+### Data Source Hunting
+```
+web-search("topic statistics site:data.gov ||| topic data site:worldbank.org ||| topic survey results", search_depth="advanced")
+```
+
+### Fact-Checking Pattern
+```
+web-search("claim fact check ||| claim evidence ||| claim debunked OR confirmed", search_depth="advanced")
+```
+
+### Local FS Search (check before web search)
+```bash
+# Search past research and memory
+grep -r "keyword" workspace/.kortix/research/ workspace/.kortix/memory/
+
+# Semantic search if available
+lss "research question" -p /workspace/.kortix/ --json -k 10
+```
+
+## Handling Edge Cases
+
+- **No good results found:** State what was searched and that evidence is lacking. This is a valid finding.
+- **Highly technical topics:** Search for both technical papers and accessible explainers.
+- **Rapidly evolving topics:** Prioritize recency. Note publication dates prominently.
+- **Controversial topics:** Present all major viewpoints with evidence. Don't editorialize.
+- **Paywalled sources:** Extract what's available from abstracts and secondary reporting. Note when full text was not accessible.
+- **Resuming prior research:** If a research directory already exists, read the existing plan, notes, and sources-index. Continue from where the previous session left off rather than starting over.

package/opencode/skills/KORTIX-docx/SKILL.md

@@ -0,0 +1,398 @@
+---
+name: kortix-docx
+description: "Use this skill whenever the user wants to create, read, edit, or manipulate Word documents (.docx files). Triggers include: any mention of \"Word doc\", \"word document\", \".docx\", or requests to produce professional documents with formatting like tables of contents, headings, page numbers, or letterheads. Also use when extracting or reorganizing content from .docx files, inserting or replacing images in documents, performing find-and-replace in Word files, working with tracked changes or comments, or converting content into a polished Word document. If the user asks for a \"report\", \"memo\", \"letter\", \"template\", or similar deliverable as a Word or .docx file, use this skill. Do NOT use for PDFs, spreadsheets, or general coding tasks unrelated to document generation."
+---
+
+# DOCX Creation, Editing, and Analysis
+
+## Overview
+
+A .docx file is a ZIP archive containing XML files.
+
+## Quick Reference
+
+| Task | Approach |
+|------|----------|
+| Read/analyze content | `pandoc` or unpack for raw XML |
+| Create new document | Use `docx-js` -- see Creating New Documents below |
+| Edit existing document | Unpack -> edit XML -> repack -- see Editing Existing Documents below |
+| Visual review | Convert DOCX -> PDF -> PNGs via `soffice` + `pdftoppm` or `scripts/render_docx.py` |
+
+### Converting .doc to .docx
+
+```bash
+python scripts/office/soffice.py --headless --convert-to docx document.doc
+```
+
+### Reading Content
+
+```bash
+pandoc --track-changes=all document.docx -o output.md
+python scripts/office/unpack.py document.docx unpacked/
+```
+
+### Converting to Images
+
+```bash
+python scripts/office/soffice.py --headless --convert-to pdf document.docx
+pdftoppm -jpeg -r 150 document.pdf page
+```
+
+Or use the bundled render script:
+```bash
+python scripts/render_docx.py /path/to/file.docx --output_dir /tmp/docx_pages
+```
+
+### Accepting Tracked Changes
+
+```bash
+python scripts/accept_changes.py input.docx output.docx
+```
+
+---
+
+## Creating New Documents
+
+Generate .docx files with JavaScript, then validate. Install: `npm install -g docx`
+
+### Setup
+```javascript
+const { Document, Packer, Paragraph, TextRun, Table, TableRow, TableCell, ImageRun,
+        Header, Footer, AlignmentType, PageOrientation, LevelFormat, ExternalHyperlink,
+        TableOfContents, HeadingLevel, BorderStyle, WidthType, ShadingType,
+        VerticalAlign, PageNumber, PageBreak } = require('docx');
+
+const doc = new Document({ sections: [{ children: [/* content */] }] });
+Packer.toBuffer(doc).then(buffer => fs.writeFileSync("doc.docx", buffer));
+```
+
+### Validation
+After creating the file, validate it. If validation fails, unpack, fix the XML, and repack.
+```bash
+python scripts/office/validate.py doc.docx
+```
+
+### Page Size
+
+```javascript
+// CRITICAL: docx-js defaults to A4, not US Letter
+// Always set page size explicitly
+sections: [{
+  properties: {
+    page: {
+      size: {
+        width: 12240,   // 8.5 inches in DXA
+        height: 15840   // 11 inches in DXA
+      },
+      margin: { top: 1440, right: 1440, bottom: 1440, left: 1440 }
+    }
+  },
+  children: [/* content */]
+}]
+```
+
+| Paper | Width | Height | Content Width (1" margins) |
+|-------|-------|--------|---------------------------|
+| US Letter | 12,240 | 15,840 | 9,360 |
+| A4 (default) | 11,906 | 16,838 | 9,026 |
+
+**Landscape**: pass portrait dimensions and let docx-js swap:
+```javascript
+size: { width: 12240, height: 15840, orientation: PageOrientation.LANDSCAPE }
+```
+
+### Styles (Override Built-in Headings)
+
+Use Arial as default font. Keep titles black for readability.
+
+```javascript
+const doc = new Document({
+  styles: {
+    default: { document: { run: { font: "Arial", size: 24 } } },
+    paragraphStyles: [
+      { id: "Heading1", name: "Heading 1", basedOn: "Normal", next: "Normal", quickFormat: true,
+        run: { size: 32, bold: true, font: "Arial" },
+        paragraph: { spacing: { before: 240, after: 240 }, outlineLevel: 0 } },
+      { id: "Heading2", name: "Heading 2", basedOn: "Normal", next: "Normal", quickFormat: true,
+        run: { size: 28, bold: true, font: "Arial" },
+        paragraph: { spacing: { before: 180, after: 180 }, outlineLevel: 1 } },
+    ]
+  },
+  sections: [{ children: [
+    new Paragraph({ heading: HeadingLevel.HEADING_1, children: [new TextRun("Title")] }),
+  ]}]
+});
+```
+
+### Lists (NEVER use unicode bullets)
+
+```javascript
+// WRONG
+new Paragraph({ children: [new TextRun("\u2022 Item")] })
+
+// CORRECT - use numbering config
+const doc = new Document({
+  numbering: {
+    config: [
+      { reference: "bullets",
+        levels: [{ level: 0, format: LevelFormat.BULLET, text: "\u2022", alignment: AlignmentType.LEFT,
+          style: { paragraph: { indent: { left: 720, hanging: 360 } } } }] },
+      { reference: "numbers",
+        levels: [{ level: 0, format: LevelFormat.DECIMAL, text: "%1.", alignment: AlignmentType.LEFT,
+          style: { paragraph: { indent: { left: 720, hanging: 360 } } } }] },
+    ]
+  },
+  sections: [{ children: [
+    new Paragraph({ numbering: { reference: "bullets", level: 0 }, children: [new TextRun("Item")] }),
+  ]}]
+});
+```
+
+### Tables
+
+**CRITICAL: Set both `columnWidths` on the table AND `width` on each cell.**
+
+```javascript
+const border = { style: BorderStyle.SINGLE, size: 1, color: "CCCCCC" };
+const borders = { top: border, bottom: border, left: border, right: border };
+
+new Table({
+  width: { size: 9360, type: WidthType.DXA },
+  columnWidths: [4680, 4680],
+  rows: [
+    new TableRow({
+      children: [
+        new TableCell({
+          borders,
+          width: { size: 4680, type: WidthType.DXA },
+          shading: { fill: "D5E8F0", type: ShadingType.CLEAR }, // CLEAR not SOLID
+          margins: { top: 80, bottom: 80, left: 120, right: 120 },
+          children: [new Paragraph({ children: [new TextRun("Cell")] })]
+        })
+      ]
+    })
+  ]
+})
+```
+
+**Always use `WidthType.DXA`** -- never `WidthType.PERCENTAGE` (breaks in Google Docs).
+
+### Images
+
+```javascript
+new Paragraph({
+  children: [new ImageRun({
+    type: "png", // Required: png, jpg, jpeg, gif, bmp, svg
+    data: fs.readFileSync("image.png"),
+    transformation: { width: 200, height: 150 },
+    altText: { title: "Title", description: "Desc", name: "Name" }
+  })]
+})
+```
+
+### Page Breaks
+
+```javascript
+new Paragraph({ children: [new PageBreak()] })
+// Or: new Paragraph({ pageBreakBefore: true, children: [new TextRun("New page")] })
+```
+
+### Table of Contents
+
+```javascript
+new TableOfContents("Table of Contents", { hyperlink: true, headingStyleRange: "1-3" })
+```
+
+### Headers/Footers
+
+```javascript
+sections: [{
+  headers: {
+    default: new Header({ children: [new Paragraph({ children: [new TextRun("Header")] })] })
+  },
+  footers: {
+    default: new Footer({ children: [new Paragraph({
+      children: [new TextRun("Page "), new TextRun({ children: [PageNumber.CURRENT] })]
+    })] })
+  },
+  children: [/* content */]
+}]
+```
+
+### Critical Rules for docx-js
+
+- Set page size explicitly (defaults to A4)
+- Landscape: pass portrait dimensions, set `orientation: PageOrientation.LANDSCAPE`
+- Never use `\n` -- use separate Paragraph elements
+- Never use unicode bullets -- use `LevelFormat.BULLET`
+- PageBreak must be in Paragraph
+- ImageRun requires `type`
+- Always use `WidthType.DXA` for tables
+- Tables need dual widths: `columnWidths` + cell `width`
+- Use `ShadingType.CLEAR`, never SOLID
+- TOC requires HeadingLevel only
+- Override built-in styles with exact IDs: "Heading1", "Heading2", etc.
+- Include `outlineLevel` for TOC (0 for H1, 1 for H2)
+
+---
+
+## Editing Existing Documents
+
+**Follow all 3 steps in order.**
+
+### Step 1: Unpack
+```bash
+python scripts/office/unpack.py document.docx unpacked/
+```
+
+### Step 2: Edit XML
+
+Edit files in `unpacked/word/`. See XML Reference below.
+
+**Use the Edit tool directly for string replacement. Do not write Python scripts.**
+
+**Use smart quotes for new content:**
+```xml
+<w:t>Here&#x2019;s a quote: &#x201C;Hello&#x201D;</w:t>
+```
+
+| Entity | Character |
+|--------|-----------|
+| `&#x2018;` | ' (left single) |
+| `&#x2019;` | ' (right single / apostrophe) |
+| `&#x201C;` | " (left double) |
+| `&#x201D;` | " (right double) |
+
+**Adding comments:** Use `comment.py`:
+```bash
+python scripts/comment.py unpacked/ 0 "Comment text with &amp; and &#x2019;"
+python scripts/comment.py unpacked/ 1 "Reply text" --parent 0
+python scripts/comment.py unpacked/ 0 "Text" --author "Kortix Agent"
+```
+Then add markers to document.xml (see Comments in XML Reference).
+
+### Step 3: Pack
+```bash
+python scripts/office/pack.py unpacked/ output.docx --original document.docx
+```
+
+### Common Pitfalls
+
+- Replace entire `<w:r>` elements when adding tracked changes
+- Preserve `<w:rPr>` formatting -- copy original run's formatting into tracked change runs
+
+---
+
+## XML Reference
+
+### Schema Compliance
+
+- Element order in `<w:pPr>`: `<w:pStyle>`, `<w:numPr>`, `<w:spacing>`, `<w:ind>`, `<w:jc>`, `<w:rPr>` last
+- Whitespace: Add `xml:space="preserve"` to `<w:t>` with leading/trailing spaces
+- RSIDs: Must be 8-digit hex (e.g., `00AB1234`)
+
+### Tracked Changes
+
+**Insertion:**
+```xml
+<w:ins w:id="1" w:author="Kortix Agent" w:date="2025-01-01T00:00:00Z">
+  <w:r><w:t>inserted text</w:t></w:r>
+</w:ins>
+```
+
+**Deletion:**
+```xml
+<w:del w:id="2" w:author="Kortix Agent" w:date="2025-01-01T00:00:00Z">
+  <w:r><w:delText>deleted text</w:delText></w:r>
+</w:del>
+```
+
+Inside `<w:del>`: use `<w:delText>` instead of `<w:t>`.
+
+**Minimal edits** -- only mark what changes:
+```xml
+<w:r><w:t>The term is </w:t></w:r>
+<w:del w:id="1" w:author="Kortix Agent" w:date="...">
+  <w:r><w:delText>30</w:delText></w:r>
+</w:del>
+<w:ins w:id="2" w:author="Kortix Agent" w:date="...">
+  <w:r><w:t>60</w:t></w:r>
+</w:ins>
+<w:r><w:t> days.</w:t></w:r>
+```
+
+**Deleting entire paragraphs** -- also mark paragraph mark as deleted:
+```xml
+<w:p>
+  <w:pPr>
+    <w:rPr>
+      <w:del w:id="1" w:author="Kortix Agent" w:date="2025-01-01T00:00:00Z"/>
+    </w:rPr>
+  </w:pPr>
+  <w:del w:id="2" w:author="Kortix Agent" w:date="2025-01-01T00:00:00Z">
+    <w:r><w:delText>Entire paragraph content...</w:delText></w:r>
+  </w:del>
+</w:p>
+```
+
+**Rejecting another author's insertion:**
+```xml
+<w:ins w:author="Jane" w:id="5">
+  <w:del w:author="Kortix Agent" w:id="10">
+    <w:r><w:delText>their inserted text</w:delText></w:r>
+  </w:del>
+</w:ins>
+```
+
+**Restoring another author's deletion:**
+```xml
+<w:del w:author="Jane" w:id="5">
+  <w:r><w:delText>deleted text</w:delText></w:r>
+</w:del>
+<w:ins w:author="Kortix Agent" w:id="10">
+  <w:r><w:t>deleted text</w:t></w:r>
+</w:ins>
+```
+
+### Comments
+
+Markers are direct children of `w:p`, never inside `w:r`:
+
+```xml
+<w:commentRangeStart w:id="0"/>
+<w:r><w:t>commented text</w:t></w:r>
+<w:commentRangeEnd w:id="0"/>
+<w:r><w:rPr><w:rStyle w:val="CommentReference"/></w:rPr><w:commentReference w:id="0"/></w:r>
+```
+
+### Images
+
+1. Add image file to `word/media/`
+2. Add relationship to `word/_rels/document.xml.rels`
+3. Add content type to `[Content_Types].xml`
+4. Reference in document.xml with `<w:drawing>`
+
+---
+
+## Visual Review Workflow
+
+1. Convert DOCX -> PDF -> PNGs
+2. Use `scripts/render_docx.py` (requires `pdf2image` and Poppler)
+3. After each meaningful change, re-render and inspect
+4. If visual review is not possible, extract text with `python-docx` as fallback
+
+## Quality Expectations
+
+- Deliver client-ready documents: consistent typography, spacing, margins, clear hierarchy
+- Avoid formatting defects: clipped/overlapping text, broken tables, unreadable characters
+- Use ASCII hyphens only. Avoid U+2011 and other Unicode dashes
+- Re-render and inspect every page at 100% zoom before final delivery
+
+## Dependencies
+
+- **pandoc**: Text extraction
+- **docx**: `npm install -g docx` (new documents)
+- **LibreOffice**: PDF conversion (via `scripts/office/soffice.py`)
+- **Poppler**: `pdftoppm` for images
+- **python-docx**: Reading/analysis (`pip install python-docx`)
+- **pdf2image**: Rendering (`pip install pdf2image`)

package/opencode/skills/KORTIX-docx/scripts/__init__.py

@@ -0,0 +1 @@
+