daemora 1.0.1 → 1.0.3

package/skills/model-usage.md

@@ -1,182 +1,35 @@
 ---
 name: model-usage
-description: Track and report AI model API usage, costs, token counts, and spending across OpenAI, Anthropic, and Google. Use when the user asks how much they've spent, their API usage, token counts, cost breakdown, daily/monthly costs, or wants to optimize AI spending. Also check Daemora's built-in cost tracking.
+description: Track and report AI model API usage, costs, token counts, and spending across OpenAI, Anthropic, and Google. Use when the user asks how much they've spent, their API usage, token counts, cost breakdown, daily/monthly costs, or wants to optimize AI spending.
 triggers: model usage, api cost, token usage, spending, how much spent, cost breakdown, openai usage, anthropic usage, api usage, cost report, ai spending, daily cost, monthly cost
+metadata: {"daemora": {"emoji": "💰"}}
 ---
 
-## When to Use
-
-✅ Check today's/this month's API costs, per-model breakdown, token counts, cost trends, optimization suggestions, Daemora internal cost report
-
-❌ Real-time streaming token counts — use the Daemora `/costs/today` endpoint for live data
-
-## Daemora Built-in Cost Tracking
+## Daemora built-in cost tracking
 
 ```bash
-# Today's costs (all models, all tasks)
-curl -s http://localhost:8081/costs/today | python3 -c "
-import sys, json
-d = json.load(sys.stdin)
-print(f\"Today's spend: \${d.get('totalCost', 0):.4f}\")
-print(f\"Tasks: {d.get('taskCount', 0)}\")
-print(f\"Tokens: {d.get('totalTokens', 0):,} ({d.get('inputTokens',0):,} in / {d.get('outputTokens',0):,} out)\")
-if 'byModel' in d:
-    print('\\nBy model:')
-    for model, cost in sorted(d['byModel'].items(), key=lambda x: -x[1]):
-        print(f\"  {model:<40} \${cost:.4f}\")
-"
-```
-
-## Parse Daemora Cost Log Directly
-
-```python
-#!/usr/bin/env python3
-"""Parse Daemora's JSONL cost log for detailed analysis."""
-import json, os
-from pathlib import Path
-from datetime import datetime, date, timedelta
-from collections import defaultdict
-
-COST_DIR = Path("data/costs")  # adjust if different
-
-def load_cost_log(days: int = 30) -> list[dict]:
-    """Load cost entries from the last N days."""
-    entries = []
-    cutoff = date.today() - timedelta(days=days)
-    for log_file in sorted(COST_DIR.glob("*.jsonl")):
-        try:
-            file_date = date.fromisoformat(log_file.stem)
-            if file_date < cutoff:
-                continue
-        except:
-            pass
-        for line in log_file.read_text().splitlines():
-            if line.strip():
-                try:
-                    entries.append(json.loads(line))
-                except:
-                    pass
-    return entries
-
-def cost_report(days: int = 7):
-    entries = load_cost_log(days)
-    if not entries:
-        print("No cost data found")
-        return
-
-    by_day     = defaultdict(float)
-    by_model   = defaultdict(float)
-    by_tenant  = defaultdict(float)
-    total_cost = 0
-    total_in   = 0
-    total_out  = 0
-
-    for e in entries:
-        cost   = e.get("estimatedCost", 0) or 0
-        ts     = e.get("timestamp", "")[:10]
-        model  = e.get("modelId", "unknown")
-        tenant = e.get("tenantId", "default")
-
-        total_cost       += cost
-        total_in         += e.get("inputTokens", 0) or 0
-        total_out        += e.get("outputTokens", 0) or 0
-        by_day[ts]       += cost
-        by_model[model]  += cost
-        by_tenant[tenant] += cost
-
-    print(f"📊 Cost Report — Last {days} days")
-    print(f"{'═'*50}")
-    print(f"Total spend:  ${total_cost:.4f}")
-    print(f"Total tokens: {total_in+total_out:,} ({total_in:,} in / {total_out:,} out)")
-    print(f"Tasks:        {len(entries)}")
-
-    print(f"\n📅 Daily breakdown:")
-    for day in sorted(by_day.keys(), reverse=True)[:days]:
-        bar = '█' * int(by_day[day] / max(by_day.values()) * 20) if by_day else ''
-        print(f"  {day}  {bar:<20} ${by_day[day]:.4f}")
-
-    print(f"\n🤖 By model:")
-    for model, cost in sorted(by_model.items(), key=lambda x: -x[1]):
-        pct = cost / total_cost * 100 if total_cost else 0
-        print(f"  {model:<40} ${cost:.4f}  ({pct:.0f}%)")
-
-    if len(by_tenant) > 1:
-        print(f"\n👤 By tenant:")
-        for tenant, cost in sorted(by_tenant.items(), key=lambda x: -x[1]):
-            print(f"  {tenant:<30} ${cost:.4f}")
-
-cost_report(days=7)
-```
-
-## OpenAI Usage via API
-
-```python
-#!/usr/bin/env python3
-"""Check OpenAI API usage and costs for current month."""
-import os, json, urllib.request
-from datetime import date
-
-API_KEY = os.environ.get("OPENAI_API_KEY", "")
-if not API_KEY:
-    print("OPENAI_API_KEY not set")
-    exit(1)
-
-# OpenAI usage endpoint (requires org-level key for detailed breakdown)
-today = date.today()
-start = f"{today.year}-{today.month:02d}-01"
-end   = today.isoformat()
-
-req = urllib.request.Request(
-    f"https://api.openai.com/v1/usage?date={today.isoformat()}",
-    headers={"Authorization": f"Bearer {API_KEY}"}
-)
-try:
-    resp = json.loads(urllib.request.urlopen(req).read())
-    # Parse usage data
-    data = resp.get("data", [])
-    total_requests = sum(d.get("n_requests", 0) for d in data)
-    total_tokens = sum(d.get("n_context_tokens_total", 0) + d.get("n_generated_tokens_total", 0) for d in data)
-    print(f"OpenAI Usage — {today}")
-    print(f"Requests: {total_requests:,}")
-    print(f"Tokens:   {total_tokens:,}")
-    print("\nNote: Cost data available in OpenAI dashboard → Usage")
-except Exception as e:
-    print(f"Could not fetch OpenAI usage: {e}")
-    print("Check usage at: https://platform.openai.com/usage")
-```
-
-## Cost Optimization Suggestions
-
-When a user asks about costs, always include optimization tips:
-
+curl -s http://localhost:8081/costs/today
 ```
-💡 Cost Optimization Tips:
 
-1. **Model routing** — Use CODE_MODEL=anthropic:claude-sonnet-4-6 for code,
-   RESEARCH_MODEL=google:gemini-2.0-flash for research (fast + cheap).
-   Simple tasks don't need the most expensive model.
+Cost logs: `data/costs/YYYY-MM-DD.jsonl` - each entry has `modelId`, `estimatedCost`, `inputTokens`, `outputTokens`, `tenantId`.
 
-2. **Sub-agent profiles** — spawnAgent with profile="researcher" uses the
-   cheaper RESEARCH_MODEL, not the default expensive model.
+## Model cost reference (2026)
 
-3. **Per-tenant limits** — Set maxDailyCost per user to prevent runaway spending:
-   `daemora tenant set <id> maxDailyCost 1.00`
-
-4. **Global daily cap** — Set MAX_DAILY_COST=5.00 in .env
-
-5. **Task cost cap** — Set MAX_COST_PER_TASK=0.25 to kill expensive tasks early
-
-6. **Check cost/task** — Use /costs/today to see which tasks are expensive,
-   then route those to cheaper models
-```
-
-## Cost Estimates (approximate, 2026 pricing)
-
-| Model | Input (per 1M) | Output (per 1M) | Good for |
-|-------|---------------|-----------------|---------|
+| Model | Input/1M | Output/1M | Best for |
+|-------|---------|----------|---------|
 | gpt-4.1-mini | $0.15 | $0.60 | Most tasks |
 | gpt-4.1 | $2.00 | $8.00 | Complex reasoning |
 | claude-sonnet-4-6 | $3.00 | $15.00 | Code, analysis |
 | claude-opus-4-6 | $15.00 | $75.00 | Hard problems only |
 | gemini-2.0-flash | $0.075 | $0.30 | Research, summaries |
 | gemini-2.5-pro | $1.25 | $10.00 | Long context |
+
+## Cost optimization tips
+
+Always include these when a user asks about costs:
+
+1. **Route by task type** - set `CODE_MODEL`, `RESEARCH_MODEL` in `.env` for automatic routing
+2. **Sub-agent profiles** - `spawnAgent` with `profile="researcher"` uses `RESEARCH_MODEL` automatically
+3. **Per-tenant limits** - `daemora tenant set <id> maxDailyCost 1.00`
+4. **Global daily cap** - `MAX_DAILY_COST=5.00` in `.env`
+5. **Per-task cap** - `MAX_COST_PER_TASK=0.25` to kill expensive tasks early

package/skills/obsidian.md

@@ -1,207 +1,61 @@
 ---
 name: obsidian
-description: Read, create, edit, search, and manage notes in an Obsidian vault. Use when the user asks to create a note, find a note, update an Obsidian file, link notes, search their vault, or manage their knowledge base. Obsidian vaults are plain Markdown files — no special tools needed for basic operations.
-triggers: obsidian, note, vault, knowledge base, zettelkasten, markdown note, create note, find note, link note, obsidian search, obsidian plugin
+description: Read, create, edit, search, and manage notes in an Obsidian vault. Use when the user asks to create a note, find a note, update an Obsidian file, search the vault, or manage their knowledge base.
+triggers: obsidian, note, vault, knowledge base, zettelkasten, markdown note, create note, find note, link note, obsidian search
+metadata: {"daemora": {"emoji": "📓", "os": ["darwin"]}}
 ---
 
-## When to Use
-
-✅ Create notes, read notes, search vault, edit frontmatter, create links between notes, list all notes, tag management, daily notes
-
-❌ Obsidian UI automation (open a specific note visually) — use `obsidian://` URI scheme for that
-
-## Find the Vault Location
+## Find vault location
 
 ```bash
-# Obsidian tracks vaults here on macOS:
 python3 -c "
 import json, pathlib
 config = pathlib.Path.home() / 'Library/Application Support/obsidian/obsidian.json'
-if config.exists():
-    data = json.loads(config.read_text())
-    for vault in data.get('vaults', {}).values():
-        status = '✅ (open)' if vault.get('open') else ''
-        print(f\"{vault['path']} {status}\")
-else:
-    print('Obsidian config not found — vault location unknown')
+for v in json.loads(config.read_text()).get('vaults', {}).values():
+    print(v['path'], '(open)' if v.get('open') else '')
 "
-# Typical locations: ~/Documents/Obsidian/, ~/Notes/, ~/Documents/Notes/
+# Common locations: ~/Documents/Obsidian/, ~/Notes/
 ```
 
-## Read Notes
-
-```bash
-# Find all notes in vault
-find ~/Documents/Obsidian -name "*.md" | head -20
-
-# Search by content
-grep -r "search term" ~/Documents/Obsidian --include="*.md" -l
+Set `VAULT` to the path once found.
 
-# Search with context (2 lines around match)
-grep -r "search term" ~/Documents/Obsidian --include="*.md" -C 2
+## Read notes
 
-# Find notes with a specific tag
-grep -r "^tags:.*tagname\|#tagname" ~/Documents/Obsidian --include="*.md" -l
-
-# Find notes created today (macOS)
-find ~/Documents/Obsidian -name "*.md" -newer $(date -v-1d +%Y-%m-%d 2>/dev/null || date -d "1 day ago" +%Y-%m-%d) 2>/dev/null
+```bash
+find $VAULT -name "*.md" | head -20                     # list all notes
+grep -r "search term" $VAULT --include="*.md" -l        # search by content
+grep -r "#tagname" $VAULT --include="*.md" -l           # find by tag
 ```
 
-## Create a Note
+## Create a note
 
-```python
-#!/usr/bin/env python3
-from pathlib import Path
-from datetime import datetime
+Use the `writeFile` tool to create `$VAULT/Folder/Note Title.md` with YAML frontmatter:
 
-VAULT = Path.home() / "Documents/Obsidian"  # adjust to actual vault path
-
-def create_note(title: str, content: str, folder: str = "", tags: list = None):
-    """Create a note with YAML frontmatter."""
-    tags = tags or []
-    date = datetime.now().strftime("%Y-%m-%d")
-    time = datetime.now().strftime("%H:%M")
-
-    frontmatter = f"""---
-title: {title}
-date: {date}
-time: {time}
-tags: [{', '.join(tags)}]
+```markdown
 ---
-
-"""
-    target_dir = VAULT / folder if folder else VAULT
-    target_dir.mkdir(parents=True, exist_ok=True)
-
-    # Sanitize filename
-    filename = title.replace("/", "-").replace(":", "-") + ".md"
-    filepath = target_dir / filename
-
-    # Don't overwrite — append timestamp if exists
-    if filepath.exists():
-        ts = datetime.now().strftime("%Y%m%d%H%M%S")
-        filepath = target_dir / f"{title} ({ts}).md"
-
-    filepath.write_text(frontmatter + content, encoding="utf-8")
-    print(f"Created: {filepath}")
-    return filepath
-
-# Example usage:
-create_note(
-    title="Meeting Notes — Q1 Review",
-    content="## Attendees\n- Alice\n- Bob\n\n## Key Points\n- ...",
-    folder="Meetings",
-    tags=["meeting", "q1-2026"]
-)
-```
-
-## Create Daily Note
-
-```python
-#!/usr/bin/env python3
-from pathlib import Path
-from datetime import datetime
-
-VAULT = Path.home() / "Documents/Obsidian"
-DAILY_FOLDER = VAULT / "Daily Notes"
-DAILY_FOLDER.mkdir(parents=True, exist_ok=True)
-
-today = datetime.now()
-filename = today.strftime("%Y-%m-%d") + ".md"
-filepath = DAILY_FOLDER / filename
-
-if not filepath.exists():
-    content = f"""---
-date: {today.strftime('%Y-%m-%d')}
-tags: [daily]
+title: Note Title
+date: 2026-03-03
+tags: [tag1, tag2]
 ---
 
-# {today.strftime('%A, %B %d, %Y')}
-
-## 🎯 Focus Today
-
-## 📝 Notes
-
-## ✅ Tasks
-- [ ]
-
-## 💭 Reflections
-
-"""
-    filepath.write_text(content)
-    print(f"Created daily note: {filepath}")
-else:
-    print(f"Daily note already exists: {filepath}")
+# Note Title
 
-# Open it in Obsidian
-import subprocess
-subprocess.run(["open", f"obsidian://open?vault=Obsidian&file=Daily Notes/{today.strftime('%Y-%m-%d')}"])
+Content here. Link to other notes with [[Other Note]].
 ```
 
-## Edit Existing Note
-
-```python
-#!/usr/bin/env python3
-from pathlib import Path
-
-def append_to_note(note_path: str, content: str, section: str = None):
-    """Append content to a note, optionally under a specific section."""
-    path = Path(note_path)
-    existing = path.read_text(encoding="utf-8")
-
-    if section:
-        # Insert under the section heading
-        marker = f"## {section}"
-        if marker in existing:
-            idx = existing.index(marker) + len(marker)
-            # Find next line after heading
-            next_line = existing.find("\n", idx) + 1
-            updated = existing[:next_line] + "\n" + content + "\n" + existing[next_line:]
-        else:
-            updated = existing + f"\n## {section}\n\n{content}\n"
-    else:
-        updated = existing.rstrip() + f"\n\n{content}\n"
-
-    path.write_text(updated, encoding="utf-8")
-    print(f"Updated: {path}")
-
-# Example: append a task under ## ✅ Tasks
-append_to_note(
-    "/path/to/note.md",
-    "- [ ] New task item",
-    section="✅ Tasks"
-)
-```
-
-## Create Linked Notes (Wiki Links)
+## Daily note
 
-Obsidian uses `[[Note Title]]` syntax for links. When creating a note that references others:
+Create `$VAULT/Daily Notes/YYYY-MM-DD.md` with today's date.
 
-```python
-# Create a note with backlinks
-content = """
-## Related Research
-
-See [[Market Analysis 2026]] for context.
-Building on [[Previous Meeting Notes]].
-
-## Summary
-...
-"""
-```
-
-## Open Note in Obsidian (macOS)
+## Open in Obsidian (macOS)
 
 ```bash
-# Open specific note
 open "obsidian://open?vault=VAULT_NAME&file=PATH/TO/NOTE"
-
-# Open search in Obsidian
 open "obsidian://search?vault=VAULT_NAME&query=search+term"
 ```
 
-## Error Handling
+## Errors
 
-- **Vault not found**: read `~/Library/Application Support/obsidian/obsidian.json` to locate vaults; ask user to confirm vault path if multiple exist
-- **File already exists**: always check before writing; either append content or create new file with timestamp suffix
-- **Encoding issues**: always use `encoding="utf-8"` when reading/writing `.md` files
+- **Vault not found** → read `~/Library/Application Support/obsidian/obsidian.json` for vault paths
+- **File already exists** → append content or create new file with timestamp suffix
+- **Encoding** → always use UTF-8 when writing `.md` files

package/skills/pdf.md

@@ -1,211 +1,60 @@
 ---
 name: pdf
-description: Create, read, extract text from, merge, split, rotate, compress, and manipulate PDF files. Use when the user asks to create a PDF report/document, extract text from a PDF, merge PDFs, convert to PDF, or do any PDF operation. Works on macOS and Linux without paid tools.
+description: Create, read, extract text from, merge, split, compress, and manipulate PDF files. Use when the user asks to create a PDF, extract text from a PDF, merge PDFs, convert to PDF, or do any PDF operation.
 triggers: pdf, create pdf, read pdf, extract pdf, merge pdf, split pdf, convert to pdf, pdf report, pdf document, compress pdf, rotate pdf
+metadata: {"daemora": {"emoji": "📄", "requires": {"anyBins": ["wkhtmltopdf", "pandoc", "pdftotext"]}, "install": ["brew install wkhtmltopdf"]}}
 ---
 
-## When to Use
-
-✅ Create PDF reports/documents, extract text from PDFs, merge multiple PDFs, split pages, rotate, compress, convert HTML/Markdown to PDF
-
-❌ PDF form filling with complex logic → use PyPDF2 + pdfrw; PDF digital signatures → use specialized tools
-
-## Method 1: Create PDF from HTML (best quality, macOS)
+## Create PDF from HTML (best quality)
 
 ```bash
-# Install wkhtmltopdf (one-time)
 brew install wkhtmltopdf
-
-# Create HTML file, then convert
-cat > /tmp/report.html << 'EOF'
-<!DOCTYPE html>
-<html>
-<head>
-<meta charset="UTF-8">
-<style>
-  body { font-family: -apple-system, Arial, sans-serif; margin: 40px; color: #222; }
-  h1 { color: #1a1a2e; border-bottom: 2px solid #eee; padding-bottom: 10px; }
-  h2 { color: #444; margin-top: 30px; }
-  table { border-collapse: collapse; width: 100%; margin: 16px 0; }
-  th { background: #f0f4ff; padding: 10px; text-align: left; border: 1px solid #ddd; }
-  td { padding: 8px 10px; border: 1px solid #eee; }
-  .highlight { background: #fffbea; padding: 12px; border-left: 4px solid #f0c040; }
-</style>
-</head>
-<body>
-  <h1>Report Title</h1>
-  <p>Content here</p>
-</body>
-</html>
-EOF
-
-wkhtmltopdf \
-  --page-size A4 \
-  --margin-top 20mm --margin-bottom 20mm \
-  --margin-left 15mm --margin-right 15mm \
-  --encoding UTF-8 \
-  --footer-center "[page] / [topage]" \
-  --footer-font-size 9 \
+wkhtmltopdf --page-size A4 --margin-top 20mm --margin-bottom 20mm \
+  --encoding UTF-8 --footer-center "[page] / [topage]" \
   /tmp/report.html /tmp/report.pdf
-
-echo "Created: /tmp/report.pdf"
-open /tmp/report.pdf   # preview on macOS
 ```
 
-## Method 2: Create PDF with Python (cross-platform, no external binaries)
-
-```python
-#!/usr/bin/env python3
-"""Create a PDF without any system binaries — uses reportlab."""
-# Install once: pip install reportlab
-from reportlab.lib.pagesizes import A4
-from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
-from reportlab.lib.units import mm
-from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle
-from reportlab.lib import colors
+## Create PDF with Python (no binary needed)
 
-output_path = "/tmp/report.pdf"
-doc = SimpleDocTemplate(output_path, pagesize=A4,
-    leftMargin=20*mm, rightMargin=20*mm,
-    topMargin=20*mm, bottomMargin=20*mm)
-
-styles = getSampleStyleSheet()
-story = []
-
-# Title
-title_style = ParagraphStyle('Title', parent=styles['Title'],
-    fontSize=24, spaceAfter=12)
-story.append(Paragraph("Report Title", title_style))
-story.append(Spacer(1, 8*mm))
-
-# Body text
-story.append(Paragraph("Your content here. Supports <b>bold</b>, <i>italic</i>, and links.", styles['BodyText']))
-story.append(Spacer(1, 6*mm))
-
-# Table
-data = [['Column A', 'Column B', 'Column C'],
-        ['Row 1',    'Value',    '$100'],
-        ['Row 2',    'Value',    '$200']]
-table = Table(data, colWidths=[60*mm, 60*mm, 40*mm])
-table.setStyle(TableStyle([
-    ('BACKGROUND', (0,0), (-1,0), colors.HexColor('#e8eaf6')),
-    ('FONTNAME',   (0,0), (-1,0), 'Helvetica-Bold'),
-    ('GRID',       (0,0), (-1,-1), 0.5, colors.HexColor('#cccccc')),
-    ('ROWBACKGROUNDS', (0,1), (-1,-1), [colors.white, colors.HexColor('#f8f9ff')]),
-    ('PADDING',    (0,0), (-1,-1), 8),
-]))
-story.append(table)
-
-doc.build(story)
-print(f"Created: {output_path}")
+```bash
+pip install reportlab
+# Use SimpleDocTemplate, Paragraph, Table from reportlab.platypus
 ```
 
-## Read / Extract Text from PDF
-
-```python
-#!/usr/bin/env python3
-# pip install pdfplumber  (better than pypdf2 for text extraction)
-import pdfplumber, sys
+## Extract text from PDF
 
-pdf_path = sys.argv[1] if len(sys.argv) > 1 else "/path/to/file.pdf"
-
-with pdfplumber.open(pdf_path) as pdf:
-    print(f"Pages: {len(pdf.pages)}")
-    for i, page in enumerate(pdf.pages, 1):
-        text = page.extract_text()
-        if text:
-            print(f"\n--- Page {i} ---\n{text}")
-
-        # Also extract tables
-        tables = page.extract_tables()
-        for t in tables:
-            print(f"\n[Table on page {i}]")
-            for row in t:
-                print(" | ".join(str(c or '') for c in row))
+```bash
+pip install pdfplumber
+python3 -c "import pdfplumber; pdf=pdfplumber.open('file.pdf'); print(pdf.pages[0].extract_text())"
+# Or: brew install poppler && pdftotext file.pdf -
 ```
 
 ## Merge PDFs
 
-```python
-#!/usr/bin/env python3
-# pip install pypdf
-from pypdf import PdfWriter, PdfReader
-import sys
-
-output = "/tmp/merged.pdf"
-writer = PdfWriter()
-
-for path in sys.argv[1:]:
-    reader = PdfReader(path)
-    for page in reader.pages:
-        writer.add_page(page)
-
-with open(output, "wb") as f:
-    writer.write(f)
-print(f"Merged {len(sys.argv)-1} PDFs → {output}")
-```
-
-## Split PDF (extract page range)
-
-```python
-#!/usr/bin/env python3
-# pip install pypdf
-from pypdf import PdfWriter, PdfReader
-
-input_pdf = "/path/to/input.pdf"
-output_pdf = "/tmp/extracted_pages.pdf"
-start_page = 0   # 0-indexed
-end_page   = 5   # exclusive
-
-reader = PdfReader(input_pdf)
-writer = PdfWriter()
-for i in range(start_page, min(end_page, len(reader.pages))):
-    writer.add_page(reader.pages[i])
-with open(output_pdf, "wb") as f:
-    writer.write(f)
-print(f"Extracted pages {start_page+1}-{end_page} → {output_pdf}")
+```bash
+pip install pypdf
+# PdfWriter + PdfReader from pypdf
+# Or with ghostscript:
+gs -dBATCH -dNOPAUSE -q -sDEVICE=pdfwrite -sOutputFile=merged.pdf a.pdf b.pdf
 ```
 
-## Compress PDF (macOS, no install)
+## Markdown → PDF
 
 ```bash
-# Uses macOS built-in Quartz filter
-"/System/Library/Printers/Libraries/quartzfilter" \
-  /System/Library/Filters/Reduce\ File\ Size.qfilter \
-  /path/to/input.pdf /tmp/compressed.pdf
-
-# Or via Python with ghostscript
-gs -sDEVICE=pdfwrite -dCompatibilityLevel=1.5 \
-   -dPDFSETTINGS=/ebook \
-   -dNOPAUSE -dQUIET -dBATCH \
-   -sOutputFile=/tmp/compressed.pdf /path/to/input.pdf
-# PDFSET options: /screen (72dpi) /ebook (150dpi) /printer (300dpi) /prepress (300dpi HQ)
+brew install pandoc
+pandoc input.md -o output.pdf --pdf-engine=wkhtmltopdf -V geometry:margin=25mm
 ```
 
-## Convert Markdown → PDF
+## Compress PDF (macOS)
 
 ```bash
-# pip install md-to-pdf  OR  brew install pandoc
-# With pandoc (best quality):
-pandoc input.md -o output.pdf \
-  --pdf-engine=wkhtmltopdf \
-  -V geometry:margin=25mm \
-  -V fontsize=11pt
-
-# Quick and dirty with Python:
-pip install markdown weasyprint
-python3 -c "
-import markdown, weasyprint, pathlib
-md = pathlib.Path('input.md').read_text()
-html = markdown.markdown(md, extensions=['tables','fenced_code'])
-weasyprint.HTML(string=f'<html><body style=\"font-family:sans-serif;margin:40px\">{html}</body></html>').write_pdf('output.pdf')
-print('output.pdf')
-"
+gs -sDEVICE=pdfwrite -dCompatibilityLevel=1.5 -dPDFSETTINGS=/ebook \
+  -dNOPAUSE -dQUIET -dBATCH -sOutputFile=/tmp/compressed.pdf input.pdf
+# PDFSET options: /screen (72dpi) /ebook (150dpi) /printer (300dpi) /prepress (HQ)
 ```
 
-## After Creating PDF
+## After creating
 
-1. Report the output path: "PDF saved to `/tmp/report.pdf`"
-2. On macOS, offer to open it: `executeCommand("open /tmp/report.pdf")`
-3. If the user wants to send it, use `sendFile("/tmp/report.pdf", channel, sessionId)`
-4. For large reports: mention page count and file size
+1. Report the path: "PDF saved to `/tmp/report.pdf`"
+2. On macOS: `executeCommand("open /tmp/report.pdf")` to preview
+3. To send: `sendFile("/tmp/report.pdf", channel, sessionId)`