daemora 1.0.1 → 1.0.3

package/skills/gif-search.md

@@ -1,196 +1,53 @@
 ---
 name: gif-search
-description: Search for GIFs, download and send animated GIFs, create GIFs from images or video clips. Use when the user asks for a GIF, wants to find a funny/reaction GIF, send a GIF, or convert something to a GIF. Searches Giphy/Tenor by default; can create GIFs from local video too.
+description: Search for GIFs, download and send animated GIFs, create GIFs from images or video. Use when the user asks for a GIF, wants to find a reaction GIF, send a GIF, or create a GIF from video.
 triggers: gif, find gif, send gif, reaction gif, funny gif, animated gif, search gif, giphy, tenor, make gif, create gif
+metadata: {"daemora": {"emoji": "🎭"}}
 ---
 
-## When to Use
+## Search Tenor (no API key needed)
 
-✅ Find and send reaction GIFs, search Giphy/Tenor by keyword, create GIFs from video clips or image sequences, convert media to GIF
-
-❌ Large video files → use video-frames skill instead; static images → just share the image directly
-
-## Search Giphy (requires free API key)
-
-```python
-#!/usr/bin/env python3
-"""Search Giphy for GIFs by keyword."""
-import os, json, urllib.request, urllib.parse
-from pathlib import Path
-
-GIPHY_KEY = os.environ.get("GIPHY_API_KEY", "")  # free key at developers.giphy.com
-
-def search_gif(query: str, limit: int = 5, rating: str = "g") -> list[dict]:
-    """Search Giphy. Returns list of GIF info dicts."""
-    if not GIPHY_KEY:
-        # Fall back to Giphy public beta key (rate-limited)
-        key = "dc6zaTOxFJmzC"
-    else:
-        key = GIPHY_KEY
-
-    params = urllib.parse.urlencode({
-        "q": query, "api_key": key,
-        "limit": limit, "rating": rating,
-        "lang": "en"
-    })
-    url = f"https://api.giphy.com/v1/gifs/search?{params}"
-    data = json.loads(urllib.request.urlopen(url).read())
-    return [
-        {
-            "title": g["title"],
-            "url":   g["images"]["original"]["url"],
-            "mp4":   g["images"]["original"]["mp4"],
-            "preview": g["images"]["fixed_height_small"]["url"],
-            "width": int(g["images"]["original"]["width"]),
-            "height": int(g["images"]["original"]["height"]),
-        }
-        for g in data.get("data", [])
-    ]
-
-def download_gif(url: str, output: str = None) -> str:
-    """Download a GIF to a local path."""
-    if not output:
-        from datetime import datetime
-        output = f"/tmp/gif_{datetime.now().strftime('%Y%m%d%H%M%S')}.gif"
-    urllib.request.urlretrieve(url, output)
-    size = Path(output).stat().st_size
-    print(f"✅ GIF downloaded: {output} ({size//1024}KB)")
-    return output
-
-# Search and get first result
-results = search_gif("excited celebration")
-if results:
-    g = results[0]
-    print(f"Found: {g['title']}")
-    path = download_gif(g["url"])
-    # Then: sendFile(path, channel, sessionId) to send via Telegram/Slack/Discord
-```
-
-## Search Tenor (no API key needed for basic use)
-
-```python
-#!/usr/bin/env python3
-import json, urllib.request, urllib.parse
-
-def search_tenor(query: str, limit: int = 5) -> list[dict]:
-    """Search Tenor GIFs. Uses public key."""
-    params = urllib.parse.urlencode({
-        "q": query,
-        "key": "LIVDSRZULELA",   # Tenor public demo key
-        "limit": limit,
-        "media_filter": "minimal",
-        "contentfilter": "low"
-    })
-    url = f"https://tenor.googleapis.com/v2/search?{params}"
-    data = json.loads(urllib.request.urlopen(url).read())
-    return [
-        {
-            "title": r.get("content_description", ""),
-            "url":   r["media_formats"]["gif"]["url"],
-            "mp4":   r["media_formats"].get("mp4", {}).get("url", ""),
-            "size":  r["media_formats"]["gif"].get("size", 0),
-        }
-        for r in data.get("results", [])
-    ]
-
-results = search_tenor("happy dance")
-for r in results[:3]:
-    print(f"  • {r['title'][:60]} ({r['size']//1024}KB)")
-    print(f"    {r['url']}")
+```bash
+curl -s "https://tenor.googleapis.com/v2/search?q=happy+dance&key=LIVDSRZULELA&limit=5&media_filter=minimal" \
+  | python3 -c "import sys,json; [print(r['media_formats']['gif']['url']) for r in json.load(sys.stdin)['results']]"
 ```
 
-## Create GIF from Video Clip
+## Search Giphy (free key at developers.giphy.com)
 
 ```bash
-# Requires ffmpeg (brew install ffmpeg)
-VIDEO="/path/to/video.mp4"
-START="00:00:05"
-DURATION=3           # seconds
-OUTPUT="/tmp/clip.gif"
-WIDTH=480
-
-ffmpeg -ss "$START" -t "$DURATION" -i "$VIDEO" \
-  -vf "fps=10,scale=${WIDTH}:-1:flags=lanczos,split[s0][s1];[s0]palettegen=max_colors=128[p];[s1][p]paletteuse=dither=bayer" \
-  -loop 0 "$OUTPUT" -y -loglevel quiet
-
-SIZE=$(du -h "$OUTPUT" | cut -f1)
-echo "✅ GIF: $OUTPUT ($SIZE)"
+curl -s "https://api.giphy.com/v1/gifs/search?q=celebration&api_key=$GIPHY_API_KEY&limit=5&rating=g" \
+  | python3 -c "import sys,json; [print(g['images']['original']['url']) for g in json.load(sys.stdin)['data']]"
 ```
 
-## Create GIF from Image Sequence
+## Download GIF
 
 ```bash
-# Convert a series of images to GIF
-INPUT_DIR="/tmp/frames"
-OUTPUT="/tmp/animation.gif"
-DELAY=10   # delay between frames (1/100 sec) — 10 = 100ms = 10fps
-
-# Using ImageMagick (brew install imagemagick)
-convert -delay $DELAY -loop 0 "${INPUT_DIR}"/*.png "$OUTPUT"
-
-# Or with ffmpeg (better quality)
-ffmpeg -framerate 10 -pattern_type glob -i "${INPUT_DIR}/*.png" \
-  -vf "scale=480:-1:flags=lanczos,split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse" \
-  -loop 0 "$OUTPUT" -y -loglevel quiet
-
-echo "✅ GIF: $OUTPUT"
+curl -L -o /tmp/reaction.gif "GIF_URL_HERE"
 ```
 
-## Optimize GIF Size
+## Create GIF from video clip
 
 ```bash
-# GIFs can be huge — optimize before sending
-INPUT="/tmp/original.gif"
-OUTPUT="/tmp/optimized.gif"
-
-# Using gifsicle (brew install gifsicle)
-gifsicle --optimize=3 --lossy=80 "$INPUT" -o "$OUTPUT"
-
-BEFORE=$(du -h "$INPUT" | cut -f1)
-AFTER=$(du -h "$OUTPUT" | cut -f1)
-echo "Before: $BEFORE → After: $AFTER"
-
-# Or reduce size by lowering resolution
-ffmpeg -i "$INPUT" -vf "scale=320:-1:flags=lanczos" "$OUTPUT" -y -loglevel quiet
+# Requires ffmpeg (brew install ffmpeg)
+ffmpeg -ss 00:00:05 -t 3 -i video.mp4 \
+  -vf "fps=10,scale=480:-1:flags=lanczos,split[s0][s1];[s0]palettegen=max_colors=128[p];[s1][p]paletteuse=dither=bayer" \
+  -loop 0 /tmp/clip.gif -y -loglevel quiet
 ```
 
-## Full Workflow: Search → Download → Send
-
-```python
-#!/usr/bin/env python3
-"""Search for a GIF and prepare it to send via a channel."""
-
-def get_gif_for_message(query: str, channel: str = "telegram", session_id: str = "") -> str:
-    """
-    Search for a GIF matching the query, download it, return the local path.
-    Then caller uses sendFile(path, channel, session_id) to deliver it.
-    """
-    # Try Tenor first (no key needed), fall back to Giphy
-    results = search_tenor(query, limit=3)
-    if not results:
-        results = search_gif(query, limit=3)
-
-    if not results:
-        return None
+## Create GIF from image sequence
 
-    # Pick first result
-    gif_url = results[0]["url"]
-    path = download_gif(gif_url)
-    return path
-
-# Example:
-path = get_gif_for_message("thumbs up success")
-if path:
-    print(f"Ready to send: {path}")
-    # sendFile(path, "telegram", session_id)
+```bash
+ffmpeg -framerate 10 -pattern_type glob -i "/tmp/frames/*.png" \
+  -vf "scale=480:-1:flags=lanczos,split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse" \
+  -loop 0 /tmp/animation.gif -y -loglevel quiet
+# Or: brew install imagemagick && convert -delay 10 -loop 0 /tmp/frames/*.png /tmp/animation.gif
 ```
 
-## Response Format
+## Workflow
 
-When the user asks to send a GIF:
-1. Search with relevant keywords
-2. Download the best match
-3. Send via `sendFile(path, channel, sessionId)`
-4. Confirm: "Sent 🎉 GIF: [title]"
+1. Search Tenor first (no key needed), fall back to Giphy if no results
+2. Download the best match to `/tmp/reaction.gif`
+3. Send: `sendFile("/tmp/reaction.gif", channel, sessionId)`
+4. Confirm: "Sent 🎉 [GIF title]"
 
-If the channel doesn't support GIFs (plain text email), share the URL instead.
+If the channel doesn't support GIFs, share the URL instead.

package/skills/healthcheck.md

@@ -1,222 +1,40 @@
 ---
 name: healthcheck
-description: Monitor system health, check disk usage, CPU load, memory, running processes, network connectivity, and service status. Use when the user asks about system health, disk space, memory usage, CPU usage, running processes, server status, or whether a service is running. Works on macOS and Linux.
+description: Monitor system health, check disk usage, CPU load, memory, running processes, network connectivity, and service status. Use when the user asks about system health, disk space, memory usage, CPU usage, running processes, server status, or whether a service is running.
 triggers: health check, disk space, memory usage, CPU usage, system status, process running, server health, is running, disk full, system monitor, uptime, load average
+metadata: {"daemora": {"emoji": "🩺"}}
 ---
 
-## When to Use
-
-✅ Check disk space, memory, CPU, running processes, network, service uptime, port availability, web endpoint health, log tails
-
-❌ Deep profiling or performance tracing — use dedicated profilers (Instruments, perf, etc.)
-
-## Full System Health Report
-
-```bash
-python3 << 'EOF'
-import subprocess, platform, os
-from datetime import datetime
-
-def run(cmd):
-    r = subprocess.run(cmd, shell=True, capture_output=True, text=True)
-    return r.stdout.strip()
-
-print(f"🖥  System Health Report — {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
-print(f"{'─'*50}")
-
-# OS + Uptime
-print(f"OS:      {platform.system()} {platform.mac_ver()[0] or platform.release()}")
-print(f"Uptime:  {run('uptime | sed s/.*up/up/')}")
-
-# CPU
-if platform.system() == "Darwin":
-    load = os.getloadavg()
-    cpu_count = int(run("sysctl -n hw.ncpu"))
-    print(f"CPU:     load {load[0]:.2f} / {load[1]:.2f} / {load[2]:.2f}  ({cpu_count} cores)")
-else:
-    print(f"CPU:     {run('top -bn1 | grep Cpu | head -1')}")
-
-# Memory
-if platform.system() == "Darwin":
-    mem = run("vm_stat")
-    page_size = 4096
-    lines = {l.split(':')[0].strip(): int(l.split(':')[1].strip().rstrip('.'))
-             for l in mem.split('\n') if ':' in l}
-    free = (lines.get('Pages free', 0) + lines.get('Pages speculative', 0)) * page_size / 1024**3
-    active = lines.get('Pages active', 0) * page_size / 1024**3
-    wired = lines.get('Pages wired down', 0) * page_size / 1024**3
-    total = float(run("sysctl -n hw.memsize")) / 1024**3
-    used = total - free
-    print(f"Memory:  {used:.1f}GB used / {total:.1f}GB total ({free:.1f}GB free)")
-else:
-    print(f"Memory:  {run('free -h | grep Mem')}")
-
-# Disk
-import shutil
-disks = ['/'] + (['/Volumes/' + d for d in os.listdir('/Volumes')] if os.path.exists('/Volumes') else [])
-print("\nDisk Usage:")
-for disk in disks:
-    try:
-        total, used, free = shutil.disk_usage(disk)
-        pct = used / total * 100
-        bar = '█' * int(pct/5) + '░' * (20 - int(pct/5))
-        status = "⚠️" if pct > 85 else "✅"
-        print(f"  {status} {disk:<20} {bar} {pct:.0f}%  ({free/1024**3:.0f}GB free)")
-    except:
-        pass
-EOF
-```
-
-## Disk Space Check
-
-```bash
-# Quick disk check
-df -h | grep -E "^/dev|Filesystem"
-
-# Find largest directories (top 10)
-du -sh /* 2>/dev/null | sort -rh | head -10
-
-# Find large files (>100MB) in a directory
-find ~/Downloads -size +100M -exec ls -lh {} \; 2>/dev/null | sort -k5 -rh | head -20
-
-# Check inode usage (different from disk space — can be "full" with space remaining)
-df -i /
-```
-
-## Memory Usage
-
-```bash
-# macOS
-vm_stat && top -l 1 -n 0 | grep -E "PhysMem|CPU"
-
-# Top memory-consuming processes
-ps aux --sort=-%mem 2>/dev/null | head -10 || \
-ps aux | sort -k4 -rn | head -10
-```
-
-## CPU Usage
-
-```bash
-# Top CPU processes
-ps aux --sort=-%cpu 2>/dev/null | head -10 || \
-ps aux | sort -k3 -rn | head -10
-
-# macOS: CPU usage over 5 seconds
-top -l 2 -n 0 -stats cpu | tail -5
-```
-
-## Check if a Process is Running
-
-```python
-#!/usr/bin/env python3
-import subprocess, sys
-
-def is_running(process_name: str) -> tuple[bool, list[str]]:
-    """Check if a process is running. Returns (running, [pid lines])."""
-    result = subprocess.run(
-        ["pgrep", "-fl", process_name],
-        capture_output=True, text=True
-    )
-    lines = [l for l in result.stdout.strip().split('\n') if l and process_name.lower() in l.lower()]
-    return len(lines) > 0, lines
-
-# Check common services
-services = ["nginx", "postgres", "redis-server", "node", "python3", "docker"]
-for svc in services:
-    running, pids = is_running(svc)
-    icon = "✅" if running else "❌"
-    info = f"  PIDs: {', '.join(p.split()[0] for p in pids[:3])}" if running else ""
-    print(f"{icon} {svc:<20}{info}")
-```
-
-## Check Port Availability
+## Quick checks
 
 ```bash
-# Check if a port is in use
-PORT=3000
-lsof -i :$PORT 2>/dev/null | grep LISTEN || echo "Port $PORT is free"
-
-# List all listening ports
-lsof -nP -iTCP -sTCP:LISTEN 2>/dev/null | awk 'NR>1 {print $1, $9}' | sort -u
-
-# Check if a service is actually responding
-curl -s -o /dev/null -w "%{http_code}" http://localhost:3000/health
-```
-
-## HTTP Endpoint Health Check
-
-```python
-#!/usr/bin/env python3
-import urllib.request, urllib.error, time, json
-
-def check_endpoint(url: str, timeout: int = 5) -> dict:
-    """Check if an HTTP endpoint is healthy."""
-    start = time.time()
-    try:
-        req = urllib.request.Request(url)
-        with urllib.request.urlopen(req, timeout=timeout) as resp:
-            latency = (time.time() - start) * 1000
-            return {
-                "url": url,
-                "status": resp.status,
-                "latency_ms": round(latency, 1),
-                "healthy": 200 <= resp.status < 300
-            }
-    except urllib.error.HTTPError as e:
-        return {"url": url, "status": e.code, "healthy": False, "error": str(e)}
-    except Exception as e:
-        return {"url": url, "status": 0, "healthy": False, "error": str(e)}
-
-# Check multiple endpoints
-endpoints = [
-    "http://localhost:3000/health",
-    "http://localhost:8081/health",
-    "https://api.example.com/ping",
-]
-
-print("🔍 Endpoint Health Check")
-print(f"{'─'*60}")
-for ep in endpoints:
-    result = check_endpoint(ep)
-    icon = "✅" if result["healthy"] else "❌"
-    latency = f"{result['latency_ms']}ms" if result["healthy"] else result.get("error", "unreachable")
-    print(f"{icon} {result['status']}  {latency:<15}  {ep}")
+df -h                                                           # disk usage
+vm_stat && uptime                                               # memory + CPU (macOS)
+free -h && uptime                                               # memory + CPU (Linux)
+ps aux | sort -k3 -rn | head -10                                # top CPU processes
+ps aux | sort -k4 -rn | head -10                                # top memory processes
+lsof -i :3000 | grep LISTEN                                     # check if port in use
+lsof -nP -iTCP -sTCP:LISTEN | awk 'NR>1 {print $1, $9}' | sort -u  # all listening ports
+pgrep -fl nginx                                                 # check if process is running
+curl -s -o /dev/null -w "%{http_code}" http://localhost:3000/health  # HTTP health check
 ```
 
-## Check Recent Errors in Logs
-
-```bash
-# System log (macOS)
-log show --last 1h --predicate 'messageType == 16 or messageType == 17' \
-  --style syslog 2>/dev/null | tail -20
-
-# Application log tail
-tail -100 ~/Library/Logs/your-app/app.log 2>/dev/null | grep -iE "error|warn|fatal" | tail -20
-
-# Daemora agent logs
-tail -50 data/audit/*.jsonl 2>/dev/null | python3 -c "
-import sys, json
-for line in sys.stdin:
-    try:
-        e = json.loads(line)
-        if e.get('type') in ['error', 'warn']:
-            print(f\"{e['timestamp']} [{e['type']}] {e.get('message', '')}\")
-    except: pass
-"
-```
+## Workflow
 
-## Response Format
+1. Run the relevant checks based on what was asked
+2. Present results as a clean status dashboard
+3. Flag anything wrong - high disk %, processes not running, unreachable endpoints
+4. Suggest fixes for common issues
 
-Present health check results as a clean status dashboard:
+## Output format
 
 ```
-🖥  System Health — MacBook Pro
+🖥  System Health - [hostname]
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 ✅ Uptime:   up 3 days, 4:22
 ✅ CPU:      load 0.8 / 1.2 / 1.5  (8 cores)
-✅ Memory:   6.2GB used / 16GB total  (9.8GB free)
-⚠️ Disk /:   ████████████████░░░░ 82%  (38GB free)  ← getting full
-✅ Disk /Volumes/Data: ████░░░░░░░░░░░░░░░░ 22%  (780GB free)
+✅ Memory:   6.2GB used / 16GB total
+⚠️ Disk /:   82%  (38GB free)  - getting full
 
 Services:
 ✅ node       (PID 4821)

package/skills/image-gen.md

@@ -1,147 +1,48 @@
 ---
 name: image-gen
-description: Generate images using OpenAI's image models (gpt-image-1, DALL-E 3, DALL-E 2). Use when the user asks to create, generate, draw, or illustrate an image, photo, logo, icon, illustration, or visual. Requires OPENAI_API_KEY.
+description: Generate images using OpenAI image models (gpt-image-1, DALL-E 3, DALL-E 2). Use when the user asks to create, generate, draw, or illustrate an image, photo, logo, icon, or visual. Requires OPENAI_API_KEY.
 triggers: generate image, create image, draw, illustrate, make a picture, logo, icon, artwork, visual, dall-e, image generation, render
+metadata: {"daemora": {"emoji": "🎨"}}
 ---
 
-## When to Use
-
-✅ Creating images from text descriptions, generating logos/icons, batch image sets, product mockups, illustration requests, visual content
-
-❌ Editing existing images (use gpt-image-1 with input image), video generation, real-time/live images
-
 ## Models
 
-| Model | Best For | Max Count | Quality Options |
-|-------|---------|-----------|----------------|
-| `gpt-image-1` | Highest quality, follows prompts best | 10/call | `high`, `medium`, `low` |
-| `dall-e-3` | Artistic, stylized | 1/call | `hd`, `standard` |
-| `dall-e-2` | Fast, cheap drafts | 10/call | `standard` |
+| Model | Best for | Max/call | Quality |
+|-------|---------|----------|---------|
+| `gpt-image-1` | Highest quality, instruction-following | 10 | `high` / `medium` / `low` |
+| `dall-e-3` | Artistic, stylized | 1 | `hd` / `standard` |
+| `dall-e-2` | Fast, cheap drafts | 10 | `standard` |
 
 Default: `gpt-image-1` at `high` quality.
 
-## Single Image (Python)
-
-```python
-#!/usr/bin/env python3
-import os, base64, json, urllib.request, urllib.parse
-from datetime import datetime
-from pathlib import Path
-
-api_key = os.environ["OPENAI_API_KEY"]
-prompt  = "A sleek futuristic dashboard UI in dark mode, neon blue accents, clean typography"
-model   = "gpt-image-1"   # or "dall-e-3", "dall-e-2"
-size    = "1024x1024"     # gpt-image-1: 1024x1024, 1536x1024 (landscape), 1024x1536 (portrait)
-quality = "high"          # gpt-image-1: high/medium/low | dall-e-3: hd/standard
-
-payload = json.dumps({
-    "model": model, "prompt": prompt,
-    "n": 1, "size": size, "quality": quality,
-    "response_format": "b64_json"
-}).encode()
-
-req = urllib.request.Request(
-    "https://api.openai.com/v1/images/generations",
-    data=payload,
-    headers={"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
-)
-resp = json.loads(urllib.request.urlopen(req).read())
-
-out_dir = Path("/tmp/daemora-images")
-out_dir.mkdir(exist_ok=True)
-ts = datetime.now().strftime("%Y%m%d_%H%M%S")
-out_file = out_dir / f"image_{ts}.png"
-out_file.write_bytes(base64.b64decode(resp["data"][0]["b64_json"]))
-print(f"Saved: {out_file}")
-```
-
-## Batch Generation
-
-```python
-#!/usr/bin/env python3
-"""Generate multiple images with varied prompts and save to a gallery."""
-import os, base64, json, urllib.request, urllib.parse
-from pathlib import Path
-from datetime import datetime
-
-API_KEY = os.environ["OPENAI_API_KEY"]
-OUT_DIR = Path("/tmp/daemora-images") / datetime.now().strftime("%Y%m%d_%H%M%S")
-OUT_DIR.mkdir(parents=True, exist_ok=True)
-
-PROMPTS = [
-    "prompt 1 here",
-    "prompt 2 here",
-]
-
-def generate(prompt, model="gpt-image-1", size="1024x1024", quality="high"):
-    payload = json.dumps({
-        "model": model, "prompt": prompt,
-        "n": 1, "size": size, "quality": quality,
-        "response_format": "b64_json"
-    }).encode()
-    req = urllib.request.Request(
-        "https://api.openai.com/v1/images/generations",
-        data=payload,
-        headers={"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"}
-    )
-    return json.loads(urllib.request.urlopen(req).read())["data"][0]["b64_json"]
-
-saved = []
-for i, prompt in enumerate(PROMPTS):
-    print(f"Generating {i+1}/{len(PROMPTS)}: {prompt[:50]}...")
-    try:
-        img_b64 = generate(prompt)
-        path = OUT_DIR / f"image_{i+1:02d}.png"
-        path.write_bytes(base64.b64decode(img_b64))
-        saved.append((path, prompt))
-        print(f"  ✅ Saved: {path}")
-    except Exception as e:
-        print(f"  ❌ Failed: {e}")
-
-# Write HTML gallery
-html = f"""<!DOCTYPE html><html><head><title>Generated Images</title>
-<style>body{{background:#111;color:#eee;font-family:sans-serif;padding:20px}}
-.grid{{display:grid;grid-template-columns:repeat(auto-fill,minmax(300px,1fr));gap:16px}}
-img{{width:100%;border-radius:8px}} p{{font-size:12px;opacity:.7;margin:4px 0 12px}}</style></head>
-<body><h2>Daemora Image Generation — {len(saved)} images</h2><div class="grid">
-"""
-for path, prompt in saved:
-    html += f'<div><img src="{path.name}" alt=""><p>{prompt}</p></div>\n'
-html += "</div></body></html>"
-(OUT_DIR / "index.html").write_text(html)
-print(f"\nGallery: {OUT_DIR / 'index.html'}")
-print(f"Open: open '{OUT_DIR / 'index.html'}'")
-```
-
-## Size Options by Model
+## Sizes
 
 ```
-gpt-image-1:  1024x1024 (square) | 1536x1024 (landscape) | 1024x1536 (portrait) | auto
+gpt-image-1:  1024x1024 | 1536x1024 (landscape) | 1024x1536 (portrait)
 dall-e-3:     1024x1024 | 1792x1024 (wide) | 1024x1792 (tall)
 dall-e-2:     256x256 | 512x512 | 1024x1024
 ```
 
-## Prompt Writing Tips
+## Prompt tips
 
-- **Be specific**: "A minimalist logo for a fintech startup, dark blue on white, geometric sans-serif font" beats "a logo"
-- **Specify style**: photorealistic / watercolor / flat illustration / 3D render / oil painting
-- **Specify lighting**: soft studio lighting / dramatic shadows / golden hour / neon
-- **Specify composition**: bird's eye view / close-up / wide angle / portrait
-- **Negative guidance**: add "no text, no watermarks" if needed
+- Be specific: "minimalist fintech logo, dark blue, geometric sans-serif" beats "a logo"
+- Specify style: photorealistic / watercolor / flat illustration / 3D render
+- Specify lighting: soft studio / dramatic shadows / golden hour / neon
+- Add "no text, no watermarks" if needed
 
-## After Generation
+## Workflow
 
-Always:
-1. Save images to `/tmp/daemora-images/` or a user-specified path
-2. Report the file path(s) in the response
-3. For multiple images, open the HTML gallery: `executeCommand("open /tmp/daemora-images/*/index.html")`
-4. If the user wants to send the image, use `sendFile(path, channel, sessionId)`
+1. Use the `generateImage` tool with the user's prompt
+2. Save to `/tmp/daemora-images/image_TIMESTAMP.png`
+3. Report the path
+4. On macOS: `executeCommand("open /tmp/daemora-images/")` if multiple images
+5. To send: `sendFile(path, channel, sessionId)`
 
-## Error Handling
+## Errors
 
 | Error | Fix |
 |-------|-----|
-| 400 content policy | Rephrase prompt, remove potentially flagged terms |
-| 401 unauthorized | Check `OPENAI_API_KEY` is set and valid |
+| 400 content policy | Rephrase prompt, remove flagged terms |
+| 401 unauthorized | Check `OPENAI_API_KEY` is valid |
 | 429 rate limit | Wait 10s, retry with `n=1` |
-| 503 unavailable | Retry after 30s; fall back to dall-e-3 |
+| 503 unavailable | Retry after 30s; fall back to `dall-e-3` |