@fenixforce/edition-pro 0.1.0

package/skills/builtin/competitor-intelligence/SKILL.md

@@ -0,0 +1,39 @@
+# Competitor Intelligence
+
+## Analysis Pipeline
+
+1. **Market Researcher**: identify competitors, gather public data (pricing, features, positioning)
+2. **Feature Comparator**: build feature matrix, identify gaps and advantages
+3. **Positioning Analyst**: assess market positioning, target segments, messaging
+
+## Output: Competitive Matrix
+
+```markdown
+## Market Overview
+[Size, growth, key trends]
+
+## Competitor Profiles
+### [Competitor 1]
+- **Positioning**: [who they target and how]
+- **Strengths**: [what they do well]
+- **Weaknesses**: [where they fall short]
+- **Pricing**: [model and tiers]
+
+## Feature Comparison Matrix
+| Feature | Us | Competitor 1 | Competitor 2 |
+|---------|-----|-------------|-------------|
+| [Feature] | [status] | [status] | [status] |
+
+## Opportunities
+[Gaps in competitor offerings we can fill]
+
+## Threats
+[Where competitors are ahead or gaining]
+```
+
+## Rules
+
+- Use public information only
+- Verify claims (don't trust competitor marketing at face value)
+- Update quarterly (competitive landscape changes)
+- Focus on what's actionable, not exhaustive

package/skills/builtin/content-engine/SKILL.md

@@ -0,0 +1,82 @@
+# Content Engine
+
+Turn one idea into strong, platform-native content instead of posting the same thing everywhere.
+
+## When to Activate
+
+- writing X posts or threads
+- drafting LinkedIn posts or launch updates
+- scripting short-form video or YouTube explainers
+- repurposing articles, podcasts, demos, or docs into social content
+- building a lightweight content plan around a launch, milestone, or theme
+
+## First Questions
+
+Clarify:
+- source asset: what are we adapting from
+- audience: builders, investors, customers, operators, or general audience
+- platform: X, LinkedIn, TikTok, YouTube, newsletter, or multi-platform
+- goal: awareness, conversion, recruiting, authority, launch support, or engagement
+
+## Core Rules
+
+1. Adapt for the platform. Do not cross-post the same copy.
+2. Hooks matter more than summaries.
+3. Every post should carry one clear idea.
+4. Use specifics over slogans.
+5. Keep the ask small and clear.
+
+## Platform Guidance
+
+### X
+- open fast
+- one idea per post or per tweet in a thread
+- keep links out of the main body unless necessary
+- avoid hashtag spam
+
+### LinkedIn
+- strong first line
+- short paragraphs
+- more explicit framing around lessons, results, and takeaways
+
+### TikTok / Short Video
+- first 3 seconds must interrupt attention
+- script around visuals, not just narration
+- one demo, one claim, one CTA
+
+### YouTube
+- show the result early
+- structure by chapter
+- refresh the visual every 20-30 seconds
+
+### Newsletter
+- deliver one clear lens, not a bundle of unrelated items
+- make section titles skimmable
+- keep the opening paragraph doing real work
+
+## Repurposing Flow
+
+Default cascade:
+1. anchor asset: article, video, demo, memo, or launch doc
+2. extract 3-7 atomic ideas
+3. write platform-native variants
+4. trim repetition across outputs
+5. align CTAs with platform intent
+
+## Deliverables
+
+When asked for a campaign, return:
+- the core angle
+- platform-specific drafts
+- optional posting order
+- optional CTA variants
+- any missing inputs needed before publishing
+
+## Quality Gate
+
+Before delivering:
+- each draft reads natively for its platform
+- hooks are strong and specific
+- no generic hype language
+- no duplicated copy across platforms unless requested
+- the CTA matches the content and audience

package/skills/builtin/context7-docs/SKILL.md

@@ -0,0 +1,145 @@
+---
+name: context7-docs
+description: "Use this skill whenever the agent needs current, accurate documentation for any programming library or framework before writing code. Triggers: any code generation task involving external libraries, 'how do I use X', 'set up Y', 'configure Z', version-specific API questions, or whenever the agent's training data might be outdated for a library. Prevents hallucinated APIs and outdated patterns by injecting real documentation into context."
+license: MIT
+---
+
+# Context7: Live Library Documentation
+
+## What This Skill Does
+
+Context7 fetches current, version-specific documentation and code examples from official sources and injects them into the agent's context. Eliminates the #1 cause of bad code generation: outdated training data producing hallucinated APIs, renamed methods, and deprecated patterns.
+
+## When to Activate
+
+- Before writing code that uses ANY external library or framework
+- User asks "how do I set up X" for any library
+- User asks about a specific library version ("Next.js 15", "React 19", "Bun 1.2")
+- Agent is about to generate code using an API it hasn't verified is current
+- User reports "that method doesn't exist" or "that API changed"
+- Any fast-moving library: Next.js, React, Tailwind, Prisma, Drizzle, Hono, tRPC, Zod, etc.
+
+## MCP Connection
+
+Context7 runs as a remote MCP server by Upstash.
+
+**Server URL:** `https://mcp.context7.com/mcp`
+**Auth:** API key required (set via `CONTEXT7_API_KEY` header or env var)
+**Protocol:** Streamable HTTP
+
+### Fenix MCP Registry Entry
+
+```json
+{
+  "name": "context7",
+  "url": "https://mcp.context7.com/mcp",
+  "auth": {
+    "type": "header",
+    "key": "CONTEXT7_API_KEY",
+    "envVar": "CONTEXT7_API_KEY"
+  },
+  "description": "Up-to-date library documentation and code examples",
+  "tools": ["resolve-library-id", "get-library-docs"]
+}
+```
+
+### Getting an API Key
+
+Sign up at `context7.com/dashboard`. Free tier available with rate limits. Higher tiers for production use.
+
+## Available Tools
+
+### 1. `resolve-library-id`
+
+Converts a library name into Context7's internal ID. Must be called before `get-library-docs` unless the user provides a direct ID in `/org/project` format.
+
+**Input:** `{ "libraryName": "next.js" }`
+**Returns:** List of matching libraries with IDs, descriptions, trust scores, and code snippet counts
+
+**Selection criteria when multiple results match:**
+1. Name similarity (exact matches first)
+2. Description relevance
+3. Code snippet count (higher = better coverage)
+4. Trust score (7-10 = authoritative)
+
+**Do not call this more than 3 times per question.** If no good match after 3 attempts, use best available result.
+
+### 2. `get-library-docs` (also called `query-docs`)
+
+Fetches documentation for a specific library using its Context7 ID.
+
+**Input:**
+```json
+{
+  "libraryId": "/vercel/next.js",
+  "query": "How to set up middleware with JWT authentication",
+  "tokens": 5000
+}
+```
+
+**Parameters:**
+- `libraryId` (required): Context7 library ID from `resolve-library-id`
+- `query` (required): Specific, detailed question. Good: "How to set up authentication with JWT in Express.js". Bad: "auth" or "hooks"
+- `tokens` (optional): Max tokens to return. Default varies. Use 5000-10000 for detailed answers
+
+**Returns:** Documentation snippets and code examples matching the query
+
+**Do not call this more than 3 times per question.** Use best information available after 3 calls.
+
+## Workflow
+
+### Standard Code Generation
+
+```
+1. User asks to implement something using library X
+2. resolve-library-id({ libraryName: "X" })
+   → Get the Context7 library ID
+3. get-library-docs({ libraryId: "/org/X", query: "specific task description" })
+   → Get current API docs and examples
+4. Write code based on the REAL documentation, not training data
+```
+
+### Version-Specific Query
+
+```
+1. User mentions a specific version ("Next.js 15 middleware")
+2. resolve-library-id({ libraryName: "next.js" })
+   → Look for version-specific entries like "/vercel/next.js/v15.0.0"
+3. get-library-docs with the versioned ID
+4. Generate code matching that exact version's API
+```
+
+### Direct Library ID (Skip Resolution)
+
+When the user provides a library ID directly using `/org/project` format:
+
+```
+User: "How do I use /supabase/supabase for auth?"
+1. Skip resolve-library-id entirely
+2. get-library-docs({ libraryId: "/supabase/supabase", query: "authentication setup" })
+3. Generate code from current docs
+```
+
+## Rules
+
+- ALWAYS fetch docs before generating code for external libraries. Do not trust training data for API shapes
+- Write specific, detailed queries. "How to configure rate limiting middleware in Express.js" beats "express middleware"
+- Do not call either tool more than 3 times per question. Use best available information after 3 calls
+- If a library has no Context7 coverage, inform the user and fall back to training data with a disclaimer
+- Cache frequently-used library IDs in agent memory to skip resolution on repeat queries
+- For well-established, slow-changing libraries (lodash, etc.), Context7 is optional. For anything that ships new versions quarterly or faster, Context7 is mandatory
+- Never include API keys, passwords, or sensitive data in queries
+
+## Libraries with Known High Coverage
+
+These are commonly indexed and well-covered:
+
+React, Next.js, Vue, Nuxt, Svelte, Angular, Express, Hono, Fastify, Prisma, Drizzle, Supabase, Tailwind CSS, shadcn/ui, tRPC, Zod, TypeScript, Node.js, Bun, Deno, PostgreSQL, MongoDB, Redis (Upstash), AWS SDK, Cloudflare Workers, Vercel, Stripe, Auth.js
+
+## Integration with Other Skills
+
+- **deepwiki-research:** Use DeepWiki for "how does this library work internally?" Use Context7 for "what's the current API for this library?" They solve different problems.
+- **frontend-development:** Always pull React/Next.js/Vue docs before generating component code
+- **backend-development:** Always pull Express/Hono/Fastify docs before generating server code
+- **database-design:** Pull Prisma/Drizzle docs before generating schema or migration code
+- **api-development:** Pull framework docs before generating route handlers

package/skills/builtin/copywriting/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: copywriting
+description: "Use this skill when the user asks to write marketing copy, landing page text, ad copy, email campaigns, product descriptions, or CTAs. Triggers: 'copy', 'landing page text', 'ad copy', 'email campaign', 'product description', 'CTA', 'headline', 'tagline', or any persuasive commercial writing."
+license: MIT
+---
+
+# Copywriting
+
+## What This Skill Does
+
+Write persuasive marketing copy. Landing pages, ads, emails, product descriptions, taglines. Clear value propositions, compelling calls to action, audience-aware tone.
+
+## Formulas
+
+### AIDA (Landing Pages)
+- **Attention**: Bold headline addressing the core desire or pain
+- **Interest**: Expand with specific benefits and proof
+- **Desire**: Paint the after-state, testimonials, social proof
+- **Action**: Clear, single CTA with urgency
+
+### PAS (Email, Short-form)
+- **Problem**: Name the specific pain point
+- **Agitate**: Show consequences of not solving it
+- **Solution**: Present the offer as the answer
+
+### BAB (Product Descriptions)
+- **Before**: Current frustrating state
+- **After**: Life with the product
+- **Bridge**: How the product gets them there
+
+## Rules
+
+- One CTA per page/email. Never compete with yourself.
+- Benefits over features ("Save 4 hours weekly" beats "AI-powered automation")
+- Specific numbers over vague claims ("147 companies" beats "many companies")
+- Write at 8th grade reading level for broad audiences
+- Test headlines: write 10, pick the best 2, A/B test those
+- Every email needs: subject line (under 50 chars), preview text (under 90 chars), single CTA.

package/skills/builtin/corrective-rag/SKILL.md

@@ -0,0 +1,19 @@
+# Corrective RAG
+## Pipeline
+1. **Retrieve**: query vector store, get top-K results
+2. **Grade**: for each result, classify RELEVANT or IRRELEVANT (lightweight LLM call or cosine threshold)
+3. **Decide**:
+   - If majority relevant → generate from retrieved docs
+   - If majority irrelevant → fall back to web search
+   - If mixed → combine best retrieved docs with web search results
+4. **Generate**: answer grounded in best available sources
+5. **Cite**: attribute each claim to its source
+
+## Grading Prompt
+"Does this document contain information relevant to answering the question? Respond YES or NO with a one-sentence reason."
+
+## Rules
+- Never generate from irrelevant retrievals (the whole point of corrective RAG)
+- Web search fallback is a feature, not a failure
+- Log grade results for retrieval quality monitoring
+- Tune relevance threshold based on false positive/negative rates.

package/skills/builtin/cost-optimization/SKILL.md

@@ -0,0 +1,131 @@
+---
+name: cost-optimization
+description: "Use this skill when optimizing LLM API costs, reducing token usage, implementing caching strategies, or managing API budgets. Triggers: 'cost', 'budget', 'expensive', 'optimize tokens', 'reduce cost', 'API spending', 'quota', 'cheaper', or any concern about LLM/API costs."
+license: MIT
+---
+
+# Cost Optimization
+
+## What This Skill Does
+
+Reduce LLM API costs through caching, model routing, batching, and token reduction.
+
+## Strategies
+
+### 1. Prompt Caching (up to 90% savings)
+Cache static system prompts and frequently-used context. Anthropic and OpenAI both support cache_control headers. Only the changing parts (user message) cost full price.
+
+### 2. Model Routing (50-80% savings)
+Route simple queries to cheap models, complex queries to expensive models.
+```
+Simple (greeting, lookup): Haiku/GPT-4o-mini ($0.25/M tokens)
+Medium (code gen, analysis): Sonnet/GPT-4o ($3/M tokens)
+Complex (reasoning, planning): Opus/o1 ($15/M tokens)
+```
+
+### 3. Batch Processing (50% cost reduction)
+Group non-urgent requests into batch API calls. Most providers offer 50% discount for batch processing with 24-hour SLA.
+
+### 4. Token Reduction
+- Compress system prompts (remove redundancy, use abbreviations)
+- Progressive disclosure for memory (stubs first, expand on demand)
+- Summarize long conversations instead of sending full history
+- Set max_tokens to limit response length
+
+### 5. Caching Responses
+Cache deterministic queries (same input = same output). Use Redis or in-memory cache with TTL.
+
+## Cost Monitoring
+
+Track per-request: model used, input tokens, output tokens, cached tokens, cost.
+Alert when daily spend exceeds budget threshold.
+
+## Rules
+
+- Always use the cheapest model that produces acceptable quality
+- Cache everything that can be cached
+- Monitor costs daily, not monthly (catch spikes early)
+- Set hard budget limits with circuit breakers
+- Log whether token counts are native (from API response) or estimated
+
+## LLM Router (RouteLLM pattern)
+
+Classify query complexity at zero LLM cost, route to appropriate model tier:
+```
+Simple (greeting, lookup, formatting): cheapest model ($0.25/M tokens)
+Medium (code gen, summarization, analysis): mid-tier model ($3/M tokens)
+Complex (multi-step reasoning, planning, creative): expensive model ($15/M tokens)
+```
+
+RouteLLM's matrix factorization classifier runs in <1ms with no API calls.
+
+## Context Minimization (Aggressive Pruning)
+
+Beyond compression, actively remove context that no longer contributes:
+
+### Pruning Rules
+1. **Redundant tool results**: if a file was read 3 times, keep only the latest read
+2. **Superseded outputs**: if code was edited multiple times, keep only the final version
+3. **Resolved errors**: once an error is fixed, collapse the error + fix into a one-line note
+4. **Conversation history**: summarize older turns into a running context summary (<200 tokens per 10 turns)
+
+### Implementation
+```typescript
+function pruneContext(messages: Message[]): Message[] {
+  const fileReads = new Map<string, Message>(); // keep latest read per file
+  const pruned: Message[] = [];
+  for (const msg of messages) {
+    if (msg.type === "tool_result" && msg.toolName === "read_file") {
+      fileReads.set(msg.filePath, msg); // overwrite previous reads
+    } else {
+      pruned.push(msg);
+    }
+  }
+  return [...pruned, ...fileReads.values()];
+}
+```
+
+## Prompt Caching via Exact Prefix Preservation
+
+Maximize cache hits by keeping the prompt prefix stable:
+
+### Prefix Ordering Strategy
+1. System prompt (static) — always cached
+2. Skill manifests (static per session) — cached after first call
+3. Project context (CLAUDE.md, file tree) — stable, rarely changes
+4. Conversation history — changes every turn (cache-bust boundary)
+
+### Cache-Bust Detection
+- Monitor `cache_creation_input_tokens` vs `cache_read_input_tokens` in API responses
+- If cache reads drop to 0, something changed in the prefix — investigate
+- Common cache busters: reordering skills, modifying system prompt mid-session, injecting dynamic content before static content
+
+## Oracle-and-Worker (Multi-Model Cost Escalation)
+
+Use cheap models for routine work, escalate to expensive models only when stuck:
+
+```
+Worker (Haiku/GPT-4o-mini) attempts task
+  ├─ Success → return result (cost: $0.25/M tokens)
+  └─ Stuck (3 attempts failed, low confidence, complex reasoning needed)
+      → Oracle (Opus/o1) consulted for guidance (cost: $15/M tokens)
+      → Worker continues with oracle's guidance
+```
+
+### Trigger Conditions for Oracle Consultation
+- Worker has failed the same subtask 3 times
+- Worker's confidence score drops below threshold
+- Task requires multi-step reasoning or architectural decisions
+- Worker explicitly requests escalation
+
+### Rules
+- Oracle provides guidance, not implementation (keep oracle calls short)
+- Log all escalations with reason (helps tune the routing threshold)
+- Target: <5% of tasks should need oracle consultation
+
+## Context Compression (Headroom pattern)
+
+Before injecting context (logs, documents, conversation history), compress 50-90% while preserving accuracy:
+- Strip noise (timestamps on routine logs, boilerplate headers, repeated patterns)
+- Keep the "needle" (critical errors, key decisions, unique information)
+- Tested with needle-in-haystack benchmark: accuracy preserved at 10% of original token count

package/skills/builtin/crypto-vulnerability-analyst/SKILL.md

@@ -0,0 +1,64 @@
+# Crypto Vulnerability Analyst
+
+## Purpose
+Find exploitable cryptographic weakness across primitive choice, implementation details, and protocol flow.
+
+## Inputs
+- `code_or_binary_context`
+- `protocol_description`
+- `key_management_model`
+
+## Workflow
+### Phase 1: Crypto Inventory
+1. Identify algorithms, modes, and libraries.
+2. Identify key derivation and randomness sources.
+3. Identify trust anchors and certificate behavior.
+
+### Phase 2: Misuse Detection
+1. Nonce/IV reuse or predictability.
+2. Weak or obsolete algorithms/modes.
+3. Insecure comparisons and padding issues.
+4. Missing authenticity or misuse of MAC/AEAD.
+
+### Phase 3: Key Lifecycle Review
+1. Key generation entropy quality.
+2. Key storage and exposure paths.
+3. Rotation, revocation, and scope boundaries.
+
+### Phase 4: Protocol Attack Analysis
+1. Replay and reflection opportunities.
+2. Downgrade and negotiation weaknesses.
+3. Oracle-like behavior from error distinctions.
+
+### Phase 5: Risk and Fix Prioritization
+1. Separate compliance issues from exploitable flaws.
+2. Prioritize fixes by exploit practicality.
+3. Provide migration-safe remediation guidance.
+
+## Crypto Assessment Matrix
+| Area | Failure Pattern |
+|---|---|
+| encryption | unauthenticated encryption for sensitive state |
+| key management | shared static keys across tenants/environments |
+| randomness | predictable nonce/session token generation |
+| protocol | downgrade and replay not cryptographically bound |
+
+## Output Contract
+```json
+{
+  "crypto_inventory": [],
+  "misuse_findings": [],
+  "protocol_risks": [],
+  "key_management_gaps": [],
+  "prioritized_remediation": []
+}
+```
+
+## Constraints
+- Do not equate deprecated with exploitable without context.
+- Clearly label confidence when implementation visibility is partial.
+
+## Quality Checklist
+- [ ] Primitive and mode details are explicit.
+- [ ] Exploit path is technically plausible.
+- [ ] Remediation is concrete.

package/skills/builtin/customer-support/SKILL.md

@@ -0,0 +1,48 @@
+# Customer Support
+
+## Interaction Flow
+
+1. **Identify**: recognize returning customers from memory. Reference past interactions naturally.
+2. **Classify**: categorize issue (billing, technical, feature request, bug report, general inquiry)
+3. **Resolve**: follow knowledge base for known issues. Escalate unknown issues.
+4. **Track**: log resolution, update customer memory, set follow-up if needed.
+
+## Escalation Rules
+
+- **Tier 1** (agent handles): FAQs, known issues with documented solutions, account inquiries
+- **Tier 2** (escalate): bugs needing investigation, billing disputes, feature requests
+- **Tier 3** (urgent): security issues, data loss, service outages, legal/compliance
+
+## Memory Integration
+
+Save to memory after every interaction:
+- Issue type and resolution
+- Customer preferences and history
+- Unresolved items needing follow-up
+
+Check memory before every response to avoid asking for information already provided.
+
+## Output Format
+
+```markdown
+## Ticket: [ID]
+**Customer**: [name/ID]
+**Category**: [billing/technical/feature/bug/inquiry]
+**Priority**: [low/medium/high/urgent]
+
+## Issue
+[Description]
+
+## Resolution
+[Steps taken and outcome]
+
+## Follow-up
+[Next steps, if any, with timeline]
+```
+
+## Rules
+
+- Acknowledge the problem before solving it
+- Never blame the customer
+- If you can't resolve, give a concrete next step and timeline
+- Follow up on unresolved issues (use scheduler)

package/skills/builtin/customer-voice-support/SKILL.md

@@ -0,0 +1,43 @@
+# Customer Voice Support
+
+## Pipeline
+
+1. **Ingest**: crawl support documentation (Firecrawl or content pipeline) -> chunk -> embed -> store in vector DB
+2. **Listen**: STT captures customer speech
+3. **Retrieve**: embed query -> search vector store -> get relevant documentation chunks
+4. **Generate**: LLM generates response grounded in retrieved docs
+5. **Speak**: TTS delivers response
+
+## Voice-Specific Rules
+
+- Responses under 30 words (voice attention span is shorter than text)
+- No formatting, bullet points, or markdown (spoken output)
+- Spell out numbers and abbreviations
+- Confirm understanding before proceeding: "I understand you're having trouble with [X]. Is that right?"
+- Offer to transfer to a human when confidence is low
+
+## Integration
+
+Uses Fenix voice pipeline (STT -> LLM -> TTS) with RAG retrieval injected as context.
+
+## RAG Configuration
+
+```markdown
+## Knowledge Base Setup
+1. Crawl support docs, FAQs, troubleshooting guides
+2. Chunk into 200-500 token segments with overlap
+3. Embed using workspace embedding model
+4. Store in vector database with metadata (category, last updated)
+
+## Retrieval Settings
+- Top-k: 3-5 most relevant chunks
+- Similarity threshold: 0.7 minimum
+- Prefer recent documents when scores are similar
+```
+
+## Rules
+
+- Always confirm understanding before providing a solution
+- Keep responses conversational and natural for speech
+- If confidence is below threshold, offer human transfer
+- Log all interactions for quality review

package/skills/builtin/data-analysis/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: data-analysis
+description: "Use this skill when the user asks to analyze data, parse CSVs, generate statistics, identify trends, or create data visualizations. Triggers: 'analyze data', 'CSV', 'JSON data', 'statistics', 'trends', 'chart', 'graph', 'data visualization', 'report from data', or any request to extract insights from structured data."
+license: MIT
+---
+
+# Data Analysis
+
+## What This Skill Does
+
+Parse, analyze, and visualize data. CSV/JSON processing, statistical analysis, trend identification, and visualization recommendations.
+
+## Data Processing
+
+```typescript
+import Papa from "papaparse";
+
+// Parse CSV
+const result = Papa.parse(csvString, { header: true, dynamicTyping: true, skipEmptyLines: true });
+const data = result.data;
+
+// Basic stats
+const values = data.map(row => row.amount);
+const sum = values.reduce((a, b) => a + b, 0);
+const avg = sum / values.length;
+const sorted = [...values].sort((a, b) => a - b);
+const median = sorted[Math.floor(sorted.length / 2)];
+const min = sorted[0];
+const max = sorted[sorted.length - 1];
+```
+
+## Analysis Workflow
+
+1. **Inspect:** Row count, column types, missing values, duplicates
+2. **Clean:** Handle nulls, fix types, remove duplicates, standardize formats
+3. **Analyze:** Aggregations, groupings, comparisons, correlations
+4. **Visualize:** Choose chart type based on data relationship
+5. **Report:** Key findings, anomalies, recommendations
+
+## Chart Selection
+
+| Relationship | Chart Type |
+|-------------|------------|
+| Trend over time | Line chart |
+| Comparison between categories | Bar chart |
+| Part of whole | Pie/donut (max 6 slices) |
+| Distribution | Histogram |
+| Correlation between variables | Scatter plot |
+| Multiple metrics over time | Multi-line or stacked area |
+
+## Rules
+
+- Always show data shape first (rows, columns, sample values)
+- Handle missing data explicitly (don't silently drop rows)
+- Round numbers appropriately for the audience
+- Label all axes and include units
+- Note limitations and caveats in findings