@bohuyeshan/openagent-labforge-core 3.11.2 → 3.11.3

package/generated/skills-bundles/full/skills/data-analysis/visualization/auto-claude__paper-figure/SKILL.md

@@ -0,0 +1,281 @@
+---
+name: "auto-claude/paper-figure"
+description: "Generate publication-quality figures and tables from experiment results. Use when user says \"画图\", \"作图\", \"generate figures\", \"paper figures\", or needs plots for a paper."
+argument-hint: ["figure-plan-or-data-path"]
+allowed-tools: "Bash(*), Read, Write, Edit, Grep, Glob, Agent, mcp__codex__codex, mcp__codex__codex-reply"
+metadata:
+  category: "data-analysis/visualization"
+---
+# Paper Figure: Publication-Quality Plots from Experiment Data
+
+Generate all figures and tables for a paper based on: **$ARGUMENTS**
+
+## Scope: What This Skill Can and Cannot Do
+
+| Category | Can auto-generate? | Examples |
+|----------|-------------------|----------|
+| **Data-driven plots** | ✅ Yes | Line plots (training curves), bar charts (method comparison), scatter plots, heatmaps, box/violin plots |
+| **Comparison tables** | ✅ Yes | LaTeX tables comparing prior bounds, method features, ablation results |
+| **Multi-panel figures** | ✅ Yes | Subfigure grids combining multiple plots (e.g., 3×3 dataset × method) |
+| **Architecture/pipeline diagrams** | ❌ No — manual | Model architecture, data flow diagrams, system overviews. At best can generate a rough TikZ skeleton, but **expect to draw these yourself** using tools like draw.io, Figma, or TikZ |
+| **Generated image grids** | ❌ No — manual | Grids of generated samples (e.g., GAN/diffusion outputs). These come from running your model, not from this skill |
+| **Photographs / screenshots** | ❌ No — manual | Real-world images, UI screenshots, qualitative examples |
+
+**In practice:** For a typical ML paper, this skill handles ~60% of figures (all data plots + tables). The remaining ~40% (hero figure, architecture diagram, qualitative results) need to be created manually and placed in `figures/` before running `/paper-write`. The skill will detect these as "existing figures" and preserve them.
+
+## Constants
+
+- **STYLE = `publication`** — Visual style preset. Options: `publication` (default, clean for print), `poster` (larger fonts), `slide` (bold colors)
+- **DPI = 300** — Output resolution
+- **FORMAT = `pdf`** — Output format. Options: `pdf` (vector, best for LaTeX), `png` (raster fallback)
+- **COLOR_PALETTE = `tab10`** — Default matplotlib color cycle. Options: `tab10`, `Set2`, `colorblind` (deuteranopia-safe)
+- **FONT_SIZE = 10** — Base font size (matches typical conference body text)
+- **FIG_DIR = `figures/`** — Output directory for generated figures
+- **REVIEWER_MODEL = `gpt-5.4`** — Model used via Codex MCP for figure quality review.
+
+## Inputs
+
+1. **PAPER_PLAN.md** — figure plan table (from `/paper-plan`)
+2. **Experiment data** — JSON files, CSV files, or screen logs in `figures/` or project root
+3. **Existing figures** — any manually created figures to preserve
+
+If no PAPER_PLAN.md exists, scan for data files and ask the user which figures to generate.
+
+## Workflow
+
+### Step 1: Read Figure Plan
+
+Parse the Figure Plan table from PAPER_PLAN.md:
+
+```markdown
+| ID | Type | Description | Data Source | Priority |
+|----|------|-------------|-------------|----------|
+| Fig 1 | Architecture | ... | manual | HIGH |
+| Fig 2 | Line plot | ... | figures/exp.json | HIGH |
+```
+
+Identify:
+- Which figures can be auto-generated from data
+- Which need manual creation (architecture diagrams, etc.)
+- Which are comparison tables (generate as LaTeX)
+
+### Step 2: Set Up Plotting Environment
+
+Create a shared style configuration script:
+
+```python
+# paper_plot_style.py — shared across all figure scripts
+import matplotlib.pyplot as plt
+import matplotlib
+matplotlib.rcParams.update({
+    'font.size': FONT_SIZE,
+    'font.family': 'serif',
+    'font.serif': ['Times New Roman', 'Times', 'DejaVu Serif'],
+    'axes.labelsize': FONT_SIZE,
+    'axes.titlesize': FONT_SIZE + 1,
+    'xtick.labelsize': FONT_SIZE - 1,
+    'ytick.labelsize': FONT_SIZE - 1,
+    'legend.fontsize': FONT_SIZE - 1,
+    'figure.dpi': DPI,
+    'savefig.dpi': DPI,
+    'savefig.bbox': 'tight',
+    'savefig.pad_inches': 0.05,
+    'axes.grid': False,
+    'axes.spines.top': False,
+    'axes.spines.right': False,
+    'text.usetex': False,  # set True if LaTeX is available
+    'mathtext.fontset': 'stix',
+})
+
+# Color palette
+COLORS = plt.cm.tab10.colors  # or Set2, or colorblind-safe
+
+def save_fig(fig, name, fmt=FORMAT):
+    """Save figure to FIG_DIR with consistent naming."""
+    fig.savefig(f'{FIG_DIR}/{name}.{fmt}')
+    print(f'Saved: {FIG_DIR}/{name}.{fmt}')
+```
+
+### Step 3: Auto-Select Figure Type
+
+Use this decision tree for data-driven figures (inspired by Imbad0202/academic-research-skills):
+
+| Data Pattern | Recommended Type | Size |
+|-------------|-----------------|------|
+| X=time/steps, Y=metric | Line plot | 0.48\textwidth |
+| Methods × 1 metric | Bar chart | 0.48\textwidth |
+| Methods × multiple metrics | Grouped bar / radar | 0.95\textwidth |
+| Two continuous variables | Scatter plot | 0.48\textwidth |
+| Matrix / grid values | Heatmap | 0.48\textwidth |
+| Distribution comparison | Box/violin plot | 0.48\textwidth |
+| Multi-dataset results | Multi-panel (subfigure) | 0.95\textwidth |
+| Prior work comparison | LaTeX table | — |
+
+### Step 4: Generate Each Figure
+
+For each figure in the plan, create a standalone Python script:
+
+**Line plots** (training curves, scaling):
+```python
+# gen_fig2_training_curves.py
+from paper_plot_style import *
+import json
+
+with open('figures/exp_results.json') as f:
+    data = json.load(f)
+
+fig, ax = plt.subplots(1, 1, figsize=(5, 3.5))
+ax.plot(data['steps'], data['fac_loss'], label='Factorized', color=COLORS[0])
+ax.plot(data['steps'], data['crf_loss'], label='CRF-LR', color=COLORS[1])
+ax.set_xlabel('Training Steps')
+ax.set_ylabel('Cross-Entropy Loss')
+ax.legend(frameon=False)
+save_fig(fig, 'fig2_training_curves')
+```
+
+**Bar charts** (comparison, ablation):
+```python
+fig, ax = plt.subplots(1, 1, figsize=(5, 3))
+methods = ['Baseline', 'Method A', 'Method B', 'Ours']
+values = [82.3, 85.1, 86.7, 89.2]
+bars = ax.bar(methods, values, color=[COLORS[i] for i in range(len(methods))])
+ax.set_ylabel('Accuracy (%)')
+# Add value labels on bars
+for bar, val in zip(bars, values):
+    ax.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.3,
+            f'{val:.1f}', ha='center', va='bottom', fontsize=FONT_SIZE-1)
+save_fig(fig, 'fig3_comparison')
+```
+
+**Comparison tables** (LaTeX, for theory papers):
+```latex
+\begin{table}[t]
+\centering
+\caption{Comparison of estimation error bounds. $n$: sample size, $D$: ambient dim, $d$: latent dim, $K$: subspaces, $n_k$: modes.}
+\label{tab:bounds}
+\begin{tabular}{lccc}
+\toprule
+Method & Rate & Depends on $D$? & Multi-modal? \\
+\midrule
+\citet{MinimaxOkoAS23} & $n^{-s'/D}$ & Yes (curse) & No \\
+\citet{ScoreMatchingdistributionrecovery} & $n^{-2/d}$ & No & No \\
+\textbf{Ours} & $\sqrt{\sum n_k d_k / n}$ & No & Yes \\
+\bottomrule
+\end{tabular}
+\end{table}
+```
+
+**Architecture/pipeline diagrams** (MANUAL — outside this skill's scope):
+- These require manual creation using draw.io, Figma, Keynote, or TikZ
+- This skill can generate a rough TikZ skeleton as a starting point, but **do not expect publication-quality results**
+- If the figure already exists in `figures/`, preserve it and generate only the LaTeX `\includegraphics` snippet
+- Flag as `[MANUAL]` in the figure plan and `latex_includes.tex`
+
+### Step 5: Run All Scripts
+
+```bash
+# Run all figure generation scripts
+for script in gen_fig*.py; do
+    python "$script"
+done
+```
+
+Verify all output files exist and are non-empty.
+
+### Step 6: Generate LaTeX Include Snippets
+
+For each figure, output the LaTeX code to include it:
+
+```latex
+% === Fig 2: Training Curves ===
+\begin{figure}[t]
+    \centering
+    \includegraphics[width=0.48\textwidth]{figures/fig2_training_curves.pdf}
+    \caption{Training curves comparing factorized and CRF-LR denoising.}
+    \label{fig:training_curves}
+\end{figure}
+```
+
+Save all snippets to `figures/latex_includes.tex` for easy copy-paste into the paper.
+
+### Step 7: Figure Quality Review with REVIEWER_MODEL
+
+Send figure descriptions and captions to GPT-5.4 for review:
+
+```
+mcp__codex__codex:
+  model: gpt-5.4
+  config: {"model_reasoning_effort": "xhigh"}
+  prompt: |
+    Review these figure/table plans for a [VENUE] submission.
+
+    For each figure:
+    1. Is the caption informative and self-contained?
+    2. Does the figure type match the data being shown?
+    3. Is the comparison fair and clear?
+    4. Any missing baselines or ablations?
+    5. Would a different visualization be more effective?
+
+    [list all figures with captions and descriptions]
+```
+
+### Step 8: Quality Checklist
+
+Before finishing, verify each figure (from pedrohcgs/claude-code-my-workflow):
+
+- [ ] Font size readable at printed paper size (not too small)
+- [ ] Colors distinguishable in grayscale (print-friendly)
+- [ ] **No title inside figures** — titles go only in LaTeX `\caption{}` (from pedrohcgs)
+- [ ] Legend does not overlap data
+- [ ] Axis labels have units where applicable
+- [ ] Axis labels are publication-quality (not variable names like `emp_rate`)
+- [ ] Figure width fits single column (0.48\textwidth) or full width (0.95\textwidth)
+- [ ] PDF output is vector (not rasterized text)
+- [ ] No matplotlib default title (remove `plt.title` for publications)
+- [ ] Serif font matches paper body text (Times / Computer Modern)
+- [ ] Colorblind-accessible (if using colorblind palette)
+
+## Output
+
+```
+figures/
+├── paper_plot_style.py          # shared style config
+├── gen_fig1_architecture.py     # per-figure scripts
+├── gen_fig2_training_curves.py
+├── gen_fig3_comparison.py
+├── fig1_architecture.pdf        # generated figures
+├── fig2_training_curves.pdf
+├── fig3_comparison.pdf
+├── latex_includes.tex           # LaTeX snippets for all figures
+└── TABLE_*.tex                  # standalone table LaTeX files
+```
+
+## Key Rules
+
+- **Every figure must be reproducible** — save the generation script alongside the output
+- **Do NOT hardcode data** — always read from JSON/CSV files
+- **Use vector format (PDF)** for all plots — PNG only as fallback
+- **No decorative elements** — no background colors, no 3D effects, no chart junk
+- **Consistent style across all figures** — same fonts, colors, line widths
+- **Colorblind-safe** — verify with https://davidmathlogic.com/colorblind/ if needed
+- **One script per figure** — easy to re-run individual figures when data changes
+- **No titles inside figures** — captions are in LaTeX only
+- **Comparison tables count as figures** — generate them as standalone .tex files
+
+## Figure Type Reference
+
+| Type | When to Use | Typical Size |
+|------|------------|--------------|
+| Line plot | Training curves, scaling trends | 0.48\textwidth |
+| Bar chart | Method comparison, ablation | 0.48\textwidth |
+| Grouped bar | Multi-metric comparison | 0.95\textwidth |
+| Scatter plot | Correlation analysis | 0.48\textwidth |
+| Heatmap | Attention, confusion matrix | 0.48\textwidth |
+| Box/violin | Distribution comparison | 0.48\textwidth |
+| Architecture | System overview | 0.95\textwidth |
+| Multi-panel | Combined results (subfigures) | 0.95\textwidth |
+| Comparison table | Prior bounds vs. ours (theory) | full width |
+
+## Acknowledgements
+
+Design pattern (type × style matrix) inspired by [baoyu-skills](https://github.com/jimliu/baoyu-skills). Publication style defaults and figure rules from [pedrohcgs/claude-code-my-workflow](https://github.com/pedrohcgs/claude-code-my-workflow). Visualization decision tree from [Imbad0202/academic-research-skills](https://github.com/Imbad0202/academic-research-skills).

package/generated/skills-bundles/full/skills/productivity/communication/auto-claude__feishu-notify/SKILL.md

@@ -0,0 +1,154 @@
+---
+name: "auto-claude/feishu-notify"
+description: "Send notifications to Feishu/Lark. Internal utility used by other skills, or manually via /feishu-notify. Supports push-only (webhook) and interactive (bidirectional) modes. Use when user says \"发飞书\", \"notify feishu\", or other skills need to send status updates."
+argument-hint: ["message-text"]
+allowed-tools: "Bash(curl *), Bash(cat *), Read, Glob"
+metadata:
+  category: "productivity/communication"
+---
+
+# Feishu/Lark Notification
+
+Send a notification: **$ARGUMENTS**
+
+## Overview
+
+This skill provides Feishu/Lark integration for ARIS. It is designed as an **internal utility** — other skills call it at key events (experiment done, review scored, checkpoint waiting). It can also be invoked manually.
+
+**Zero-impact guarantee**: If no `feishu.json` config exists, this skill does nothing and returns silently. All existing workflows are completely unaffected.
+
+## Configuration
+
+The skill reads `~/.claude/feishu.json`. If this file does not exist, **all Feishu functionality is disabled** — skills behave exactly as before.
+
+### Config Format
+
+```json
+{
+  "mode": "push",
+  "webhook_url": "https://open.feishu.cn/open-apis/bot/v2/hook/YOUR_WEBHOOK_ID",
+  "interactive": {
+    "bridge_url": "http://localhost:5000",
+    "timeout_seconds": 300
+  }
+}
+```
+
+### Modes
+
+| Mode | `"mode"` value | What it does | Requires |
+|------|----------------|--------------|----------|
+| **Off** | `"off"` or file absent | Nothing. Pure CLI as-is | Nothing |
+| **Push only** | `"push"` | Send webhook notifications at key events. Mobile push, no reply | Feishu bot webhook URL |
+| **Interactive** | `"interactive"` | Full bidirectional. Approve/reject from Feishu, reply to checkpoints | [feishu-claude-code](https://github.com/joewongjc/feishu-claude-code) running |
+
+## Workflow
+
+### Step 1: Read Config
+
+```bash
+cat ~/.claude/feishu.json 2>/dev/null
+```
+
+- **File not found** → return silently, do nothing
+- **`"mode": "off"`** → return silently, do nothing
+- **`"mode": "push"`** → proceed to Step 2 (push)
+- **`"mode": "interactive"`** → proceed to Step 3 (interactive)
+
+### Step 2: Push Notification (webhook)
+
+Send a rich card to the Feishu webhook:
+
+```bash
+curl -s -X POST "$WEBHOOK_URL" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "msg_type": "interactive",
+    "card": {
+      "header": {
+        "title": {"tag": "plain_text", "content": "TITLE"},
+        "template": "COLOR"
+      },
+      "elements": [
+        {"tag": "markdown", "content": "BODY"}
+      ]
+    }
+  }'
+```
+
+**Card templates by event type:**
+
+| Event | Title | Color | Body |
+|-------|-------|-------|------|
+| `experiment_done` | Experiment Complete | `green` | Results table, delta vs baseline |
+| `review_scored` | Review Round N: X/10 | `blue` (≥6) / `orange` (<6) | Score, verdict, top 3 weaknesses |
+| `checkpoint` | Checkpoint: Waiting for Input | `yellow` | Question, options, context |
+| `error` | Error: [type] | `red` | Error message, what failed |
+| `pipeline_done` | Pipeline Complete | `purple` | Final summary, deliverables |
+| `custom` | Custom | `blue` | Free-form message from $ARGUMENTS |
+
+**Return immediately after curl** — push mode never waits for a response.
+
+### Step 3: Interactive Notification (bidirectional)
+
+Interactive mode uses [feishu-claude-code](https://github.com/joewongjc/feishu-claude-code) as a bridge:
+
+1. **Send message** to the bridge:
+   ```bash
+   curl -s -X POST "$BRIDGE_URL/send" \
+     -H "Content-Type: application/json" \
+     -d '{"type": "EVENT_TYPE", "title": "TITLE", "body": "BODY", "options": ["approve", "reject", "custom"]}'
+   ```
+
+2. **Wait for reply** (with timeout):
+   ```bash
+   curl -s "$BRIDGE_URL/poll?timeout=$TIMEOUT_SECONDS"
+   ```
+   Returns: `{"reply": "approve"}` or `{"reply": "reject"}` or `{"reply": "user typed message"}` or `{"timeout": true}`
+
+3. **On timeout**: Fall back to `AUTO_PROCEED` behavior (proceed with default option).
+
+4. **Return the user's reply** to the calling skill so it can act on it.
+
+### Step 4: Verify Delivery
+
+- **Push mode**: Check curl exit code. If non-zero, log warning but do NOT block the workflow.
+- **Interactive mode**: If bridge is unreachable, fall back to push mode (if webhook configured) or skip silently.
+
+## Helper Function (for other skills)
+
+Other skills should use this pattern to send notifications:
+
+```markdown
+### Feishu Notification (if configured)
+
+Check if `~/.claude/feishu.json` exists and mode is not "off":
+- If **push** mode: send webhook notification with event summary
+- If **interactive** mode: send notification and wait for user reply
+- If **off** or file absent: skip entirely (no-op)
+```
+
+**This check is always guarded.** If the config file doesn't exist, the skill skips the notification block entirely — zero overhead, zero side effects.
+
+## Event Catalog
+
+Skills send these events at these moments:
+
+| Skill | Event | When |
+|-------|-------|------|
+| `/run-experiment` | `experiment_done` | Screen session finishes |
+| `/idea-discovery` | `checkpoint` | Between phases (if interactive) |
+| `/idea-discovery` | `pipeline_done` | Final report ready |
+| `/monitor-experiment` | `experiment_done` | Results collected |
+| `/research-pipeline` | `checkpoint` | Between workflow stages |
+| `/research-pipeline` | `pipeline_done` | Full pipeline complete |
+
+## Key Rules
+
+- **NEVER block a workflow** because Feishu is unreachable. Always fail open.
+- **NEVER require Feishu config** — all skills must work without it.
+- **Config file absent = mode off.** No error, no warning, no log.
+- **Push mode is fire-and-forget.** Send curl, check exit code, move on.
+- **Interactive timeout = auto-proceed.** Don't hang forever waiting for a reply.
+- **Respect `AUTO_PROCEED`**: In interactive mode, if the user doesn't reply within timeout, use the same auto-proceed logic as the calling skill.
+- **No secrets in notifications.** Never include API keys, tokens, or passwords in Feishu messages.

package/generated/skills-bundles/full/skills/productivity/visual-design/auto-claude__pixel-art/SKILL.md

@@ -0,0 +1,138 @@
+---
+name: "auto-claude/pixel-art"
+description: "Generate pixel art SVG illustrations for READMEs, docs, or slides. Use when user says \"画像素图\", \"pixel art\", \"make an SVG illustration\", \"README hero image\", or wants a cute visual."
+argument-hint: ["description of what to draw"]
+allowed-tools: "Write, Edit, Read, Bash(open *)"
+metadata:
+  category: "productivity/visual-design"
+---
+# Pixel Art SVG Generator
+
+Create a pixel art SVG illustration: $ARGUMENTS
+
+## Design Principles
+
+### Pixel Grid
+- Each "pixel" is a `<rect>` with width/height of 7px
+- Grid spacing: 7px (no gaps between pixels)
+- Characters are typically 8-10 pixels wide, 8-12 pixels tall
+- Use `<g transform="translate(x,y)">` to position and reuse character groups
+
+### Color Palette
+Keep it simple — 3-5 colors per character:
+- **Skin**: `#FFDAB9` (light), `#E8967A` / `#D4956A` (blush/shadow)
+- **Eyes**: `#333`
+- **Hair**: `#8B5E3C` (brown), `#2C2C2C` (black), `#FFD700` (blonde), `#C0392B` (red)
+- **Clothes**: use project's brand color (e.g. `#4A9EDA` for blue, `#74AA63` for green)
+- **Shoes/pants**: `#444`
+- **Accessories**: `#555` (glasses frames), `#FFD700` (crown)
+
+### Character Template (7px grid)
+```
+Row 0 (hair top):     4 pixels centered
+Row 1 (hair):         6 pixels wide
+Row 2 (face top):     6 pixels — all skin
+Row 3 (eyes):         6 pixels — skin, eye, skin, skin, eye, skin
+Row 4 (mouth):        6 pixels — skin, skin, mouth, mouth, skin, skin
+Row 5 (body top):     8 pixels — hand, 6 shirt, hand
+Row 6 (body):         6 pixels — all shirt
+Row 7 (legs):         2+2 pixels — with gap in middle
+```
+
+### Scene Composition
+
+#### Chat Dialogue Layout (like our hero image)
+- Two characters on left/right sides, vertically centered
+- Chat bubbles between them, alternating left/right
+- Bubble tails point toward the speaking character
+- Arrows between bubbles show direction of communication
+- Use `orient="auto"` markers for arrow heads
+- Bottom: tagline or decoration
+
+#### Single Character with Label
+- Character centered
+- Label text below
+- Optional: speech bubble above
+
+#### Group Scene
+- Characters spaced evenly
+- Optional: ground line, background elements
+- Keep viewBox tight — no wasted space
+
+### SVG Structure
+```xml
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 W H" font-family="monospace">
+  <defs>
+    <!-- Arrow markers if needed -->
+  </defs>
+
+  <rect width="W" height="H" fill="#fafbfc" rx="12"/>  <!-- Background -->
+
+  <!-- Characters via <g transform="translate(...)"> -->
+  <!-- Dialogue bubbles: <rect> + <polygon> tail + <text> -->
+  <!-- Arrows: <line> with marker-end -->
+  <!-- Labels: <text> with text-anchor="middle" -->
+</svg>
+```
+
+### Chat Bubble Recipe
+```xml
+<!-- Blue bubble (left character speaks) -->
+<rect x="110" y="29" width="280" height="26" fill="#e8f4fd" stroke="#4a9eda" stroke-width="1.5" rx="8"/>
+<!-- Tail pointing left toward character -->
+<polygon points="108,41 99,47 108,46" fill="#e8f4fd" stroke="#4a9eda" stroke-width="1.5"/>
+<rect x="107" y="40" width="3" height="7" fill="#e8f4fd"/>  <!-- covers stroke at junction -->
+<text x="123" y="46" font-size="13px">📄 Message here</text>
+
+<!-- Orange bubble (right character responds) -->
+<rect x="490" y="71" width="280" height="26" fill="#fdf2e8" stroke="#da8a4a" stroke-width="1.5" rx="8"/>
+<!-- Tail pointing right toward character -->
+<polygon points="772,83 781,89 772,88" fill="#fdf2e8" stroke="#da8a4a" stroke-width="1.5"/>
+<rect x="770" y="82" width="3" height="7" fill="#fdf2e8"/>
+<text x="503" y="88" font-size="13px">🤔 Response here</text>
+```
+
+### Arrow Recipe
+```xml
+<defs>
+  <marker id="ar" markerWidth="8" markerHeight="6" refX="8" refY="3" orient="auto">
+    <polygon points="0 0, 8 3, 0 6" fill="#4a9eda"/>
+  </marker>
+</defs>
+<!-- Right arrow (→): x1 < x2 -->
+<line x1="392" y1="42" x2="465" y2="42" stroke="#4a9eda" stroke-width="2" marker-end="url(#ar)"/>
+<!-- Left arrow (←): x1 > x2 -->
+<line x1="488" y1="84" x2="420" y2="84" stroke="#da8a4a" stroke-width="2" marker-end="url(#ar-o)"/>
+```
+
+## Workflow
+
+### Step 1: Understand the Request
+- What characters/objects to draw?
+- What's the scene? (dialogue, portrait, group, diagram)
+- What colors/brand to match?
+- What size? (compact for badge, wide for README hero)
+
+### Step 2: Generate SVG
+- Write to a temp file or project directory
+- Open with `open <file.svg>` for preview
+- Keep viewBox tight — measure actual content bounds
+
+### Step 3: Iterate with User
+- User provides feedback on screenshot
+- Common fixes: overlap, arrow direction, spacing, sizing
+- Use `Edit` for small tweaks, `Write` for major redesigns
+- Typical: 2-4 iterations to get it right
+
+### Step 4: Finalize
+- Ensure no personal info in the SVG
+- Clean up: remove unused defs, tighten viewBox
+- Suggest adding to README: `![Alt text](filename.svg)`
+
+## Common Pitfalls
+- **Arrow direction**: `orient="auto"` follows line direction. Line going right→left = arrowhead points left
+- **Bubble overlap**: keep 38-44px vertical spacing between rows
+- **Text overflow**: monospace 13px ≈ 7.8px/char, emoji ≈ 14px. Measure before setting bubble width
+- **Character overlap with bubbles**: keep character x-zone and bubble x-zone separated by ≥10px
+- **viewBox too large**: match viewBox to actual content, add ~10px padding
+- **Tail stroke artifact**: always add a small `<rect>` at the bubble-tail junction to cover the stroke line