vibebusiness 1.2.80 → 1.2.83

package/.next/standalone/templates/commands/measure-page.md

@@ -0,0 +1,89 @@
+# /measure-page — Page Performance Check
+
+## Usage
+```
+/measure-page /landing              # Measure by URL path
+/measure-page page-001              # Measure by page ID
+/measure-page all                   # Measure all tracked pages
+```
+
+## Input
+- `$ARGUMENTS` — **required**: page URL path, page ID, or "all"
+
+## Process
+
+### Step 1: Identify Page
+1. Read `data/pages.json`
+2. Find the page by:
+   - URL path match (e.g., `/landing`)
+   - Page ID match (e.g., `page-001`)
+   - If "all", process all pages with status "live"
+3. If page not found, list available pages and exit
+
+### Step 2: Gather Metrics
+Check for analytics integration:
+
+1. **KPI Adapters** — check `data/business-context.json` for configured analytics adapters
+2. **Manual Input** — if no adapter, ask the user for metrics:
+   - Bounce rate (%)
+   - Conversion rate (%)
+   - Average time on page (seconds)
+   - Total visitors (in measurement period)
+
+### Step 3: Benchmark Comparison
+Compare metrics against:
+
+1. **Industry benchmarks** (use WebSearch if needed):
+   - Landing page average bounce rate: 40-60%
+   - Landing page average conversion rate: 2-5%
+   - Good time on page: >60 seconds
+
+2. **Competitor pages** — if competitor data exists in `data/competitors.json`, compare:
+   - Our CTA clarity vs. theirs
+   - Our social proof depth vs. theirs
+   - Our headline specificity vs. theirs
+
+### Step 4: Identify Improvements
+Based on metrics and benchmarks, identify specific improvement opportunities:
+
+- **High bounce rate (>60%)** → headline mismatch, slow load, unclear value prop
+- **Low conversion (<2%)** → weak CTA, missing social proof, too many options
+- **Low time on page (<30s)** → content not engaging, poor above-the-fold
+- **Good metrics** → consider A/B test variations for further optimization
+
+For each issue, provide:
+- The specific problem
+- Evidence from the metrics
+- Recommended fix (referencing positioning data)
+- Expected impact
+
+### Step 5: Update Pages Data
+Update `data/pages.json` with the measurements:
+```json
+{
+  "metrics": {
+    "bounce_rate": 45.2,
+    "conversion_rate": 3.1,
+    "avg_time_on_page": 87,
+    "visitors": 1250
+  }
+}
+```
+
+### Step 6: Generate Optimization Ideas
+If metrics are below benchmarks, generate improvement ideas in `data/ideas.json`:
+- Category: "growth" or "ux_design"
+- Tag with page ID
+- Include specific, actionable implementation plan
+- Reference positioning data for copy improvements
+
+### Step 7: Output
+Print:
+- Current metrics vs. benchmarks (table format)
+- Performance grade (A/B/C/D/F)
+- Top 3 improvement recommendations
+- Ideas generated (if any)
+
+## Output Files
+- `data/pages.json` — updated metrics
+- `data/ideas.json` — new optimization ideas (if applicable)

package/.next/standalone/templates/commands/positioning.md

@@ -0,0 +1,128 @@
+# /positioning — Positioning & Copy Framework
+
+## Usage
+```
+/positioning                # Full analysis (default)
+/positioning copy-bank      # Regenerate copy variations using existing positioning
+/positioning refresh        # Re-analyze after new competitor data
+```
+
+## Input
+- `$ARGUMENTS` — optional: "copy-bank" or "refresh"
+
+## Process
+
+### Step 1: Load Context
+1. Read `data/competitors.json` — all competitor profiles
+2. Read `data/business-context.json` — product info, funnels, monetization
+3. Read `data/positioning.json` — existing positioning (if any)
+4. Determine mode:
+   - Empty → full analysis
+   - `"copy-bank"` → skip positioning analysis, regenerate copy only
+   - `"refresh"` → full re-analysis treating existing positioning as draft
+
+### Step 2: Market Landscape Analysis
+**Skip if mode is "copy-bank".**
+
+If no competitor data exists, run lightweight WebSearch queries:
+- `"[product category] market landscape [year]"`
+- `"[product category] comparison"`
+
+Map all competitors on these axes:
+- **Price vs. Features** — who's premium vs. budget?
+- **Audience segments** — developers, SMBs, enterprise, specific verticals?
+- **Positioning angles** — speed, simplicity, power, price, trust?
+
+Identify:
+- Which quadrants are crowded vs. empty?
+- Which audience segments are underserved?
+- What messaging angles are overused?
+
+### Step 3: Positioning Definition
+Define or refine:
+
+1. **Ideal Customer Profile (ICP)**:
+   - Primary audience: who benefits most?
+   - Secondary audiences: who else uses this?
+   - Anti-personas: who is NOT our customer? (important for focus)
+
+2. **Value Proposition**: One clear sentence — what do we do, for whom, and why is it better?
+
+3. **Differentiators**: 3-5 specific things that make us different. Each must be:
+   - True (we actually do this)
+   - Relevant (customers care about this)
+   - Unique (competitors don't do this or do it worse)
+
+4. **Messaging Pillars**: 3-4 themes that all our messaging reinforces. For each:
+   - Pillar name (e.g., "Simplicity", "Speed", "Trust")
+   - Proof points (specific evidence)
+   - Counter-objections (how to respond when challenged)
+
+### Step 4: Generate Copy Bank
+Generate copy variations segmented by funnel stage (TOFU/MOFU/BOFU) and audience:
+
+1. **Headlines** (5+ variations):
+   - TOFU: awareness/education focused
+   - MOFU: consideration/comparison focused
+   - BOFU: decision/urgency focused
+
+2. **Subheadlines** (3+ variations): support the headline with specifics
+
+3. **CTAs** (5+ variations):
+   - Primary: main action (e.g., "Start Free Trial")
+   - Secondary: lower commitment (e.g., "See Demo")
+   - Micro: in-content (e.g., "Learn More")
+
+4. **Social Proof** snippets: stats, testimonials, logos, case studies
+
+5. **Objection Handlers**: for each common objection, a concise response
+   - "Too expensive" → ...
+   - "I already use X" → ...
+   - "Is it secure?" → ...
+
+6. **Pain Points**: ranked by intensity and audience segment
+
+### Step 5: Write Output
+Write to `data/positioning.json`:
+```json
+{
+  "last_updated": "YYYY-MM-DD",
+  "current": {
+    "tagline": "...",
+    "value_proposition": "...",
+    "target_audience": {
+      "primary": "...",
+      "secondary": ["..."],
+      "anti_personas": ["..."]
+    },
+    "differentiators": ["..."],
+    "messaging_pillars": [
+      {
+        "pillar": "...",
+        "proof_points": ["..."],
+        "counter_objections": ["..."]
+      }
+    ]
+  },
+  "copy_bank": {
+    "headlines": [{ "text": "...", "audience": "...", "funnel_stage": "tofu" }],
+    "subheadlines": [{ "text": "...", "audience": "...", "funnel_stage": "tofu" }],
+    "ctas": [{ "text": "...", "context": "...", "conversion_rate": null }],
+    "social_proof": [{ "text": "...", "type": "stat" }],
+    "objection_handlers": [{ "objection": "...", "response": "..." }],
+    "pain_points": [{ "pain": "...", "audience": "...", "intensity": "high" }]
+  }
+}
+```
+
+### Step 6: Print Summary
+Print a positioning canvas:
+- Tagline and value proposition
+- ICP summary
+- Top 3 differentiators
+- Messaging pillars overview
+- Copy bank stats (N headlines, N CTAs, etc.)
+- Recommendation for next step (usually: run `/build-page`)
+
+## Output Files
+- `data/positioning.json` — positioning framework and copy bank

package/.next/standalone/templates/commands/pricing-analysis.md

@@ -0,0 +1,91 @@
+# /pricing-analysis — Pricing Strategy Analysis
+
+## Usage
+```
+/pricing-analysis            # Full pricing analysis (default)
+/pricing-analysis benchmark  # Just benchmark against competitors
+/pricing-analysis optimize   # Suggest optimizations for current pricing
+```
+
+## Input
+- `$ARGUMENTS` — optional: "benchmark" or "optimize"
+
+## Process
+
+### Step 1: Load Context
+1. Read `data/competitors.json` — all competitor pricing data
+2. Read `data/business-context.json` — our current pricing and monetization
+3. Read `data/positioning.json` — our target audience and differentiators
+4. Read `data/hypotheses.json` — existing pricing hypotheses
+
+### Step 2: Gather Pricing Data
+If competitor pricing data is incomplete, run WebSearch:
+- `"[product category] pricing [year]"`
+- `"how much does [similar product] cost"`
+- `"[product category] pricing benchmarks SaaS"`
+- For each competitor missing pricing: `"[competitor name] pricing"`
+
+### Step 3: Value Metric Analysis
+Identify what customers pay for in this market:
+- Per seat/user?
+- Per usage (API calls, messages, etc.)?
+- Per feature tier?
+- Flat rate?
+
+Map value metrics across all competitors:
+
+| Competitor | Model | Entry Price | Mid Tier | Enterprise | Free Tier |
+|-----------|-------|------------|----------|------------|-----------|
+| ... | per seat | $X/mo | $Y/mo | Custom | Yes/No |
+
+### Step 4: Pricing Gap Analysis
+Identify:
+1. **Underpriced features** — things we offer that competitors charge more for
+2. **Missing tiers** — market segments we're not addressing
+3. **Anchoring opportunities** — how to frame our pricing against competitors
+4. **Value perception** — is our pricing aligned with our positioning?
+
+### Step 5: Pricing Psychology
+Apply pricing psychology principles:
+- **Anchoring**: should we add a decoy tier?
+- **Charm pricing**: $99 vs $100 effects
+- **Tier naming**: does our naming match our audience?
+- **Feature gating**: what features should gate each tier?
+- **Annual vs monthly**: optimal discount for annual billing
+
+If needed, WebSearch for:
+- `"SaaS pricing psychology best practices [year]"`
+- `"pricing page conversion optimization"`
+
+### Step 6: Generate Recommendations
+Create specific pricing recommendations:
+
+1. **Quick wins** — changes we can make immediately
+2. **Tier restructuring** — if current tiers are suboptimal
+3. **New pricing page** — if the pricing page needs redesign
+4. **A/B test hypotheses** — experiments to validate pricing changes
+
+### Step 7: Create Hypothesis
+If pricing changes are recommended, create a hypothesis in `data/hypotheses.json`:
+```json
+{
+  "title": "Pricing change: [specific change]",
+  "statement": "If we [change], then [metric] will [improve] because [reason]",
+  "funnel_stage": "monetization",
+  "priority": "high",
+  "effort_to_test": "s",
+  "tags": ["pricing"]
+}
+```
+
+### Step 8: Output
+Print:
+- Competitive pricing comparison table
+- Value metric analysis
+- Current pricing assessment (underpriced / overpriced / well-positioned)
+- Top 3 pricing recommendations with rationale
+- Expected revenue impact
+- A/B test hypothesis (if generated)
+
+## Output Files
+- `data/hypotheses.json` — pricing test hypotheses (if applicable)

package/.next/standalone/templates/commands/promo-copy.md

@@ -0,0 +1,186 @@
+# /promo-copy — Positioning-Driven Promotional Copy Generator
+
+## Usage
+```
+/promo-copy tweet-ship            # Ship announcement tweet (≤280 chars)
+/promo-copy tweet-milestone       # KPI milestone tweet
+/promo-copy tweet-update          # Product update tweet
+/promo-copy tweet-thread          # Multi-tweet thread (3-5 tweets)
+/promo-copy ad-google {keyword}   # Google Ads copy (3 headlines + 2 descriptions)
+/promo-copy ad-meta {audience}    # Meta/Instagram ad copy
+/promo-copy linkedin              # LinkedIn post (≤3000 chars)
+/promo-copy landing {slug}        # Landing page copy block
+/promo-copy email-subject {campaign}  # 5 email subject line variations
+```
+
+## Input
+- `$ARGUMENTS` — required: copy type and optional parameters
+
+## Process
+
+Parse `$ARGUMENTS` to determine the copy type. The first token is the type, the rest are parameters.
+
+## Positioning Integration (Required)
+
+Before writing ANY copy, load `data/positioning.json` and extract:
+- **Pain points** — Lead with the most relevant one for this channel/audience
+- **Messaging pillars** — Weave 1-2 into the copy naturally
+- **Objection handlers** — Preempt 1 relevant objection where appropriate
+- **Social proof** — Include 1 credibility anchor (user count, shipped features, market validation)
+- **CTA bank** — Pull CTAs from positioning rather than inventing generic ones
+- **Headlines/Tagline** — Use copy_bank headlines as inspiration
+- **Tone** — Match the founder's voice from positioning (confident, technical, direct)
+
+Also load:
+- `data/ideas.json` — For ship/milestone tweets, get specific feature details
+- `data/goals.json` — For milestone copy, get KPI data
+- `data/business-context.json` — Product info, audience, value proposition
+
+## Copy Quality Rules
+
+These rules apply to ALL copy types. They override generic instincts.
+
+### Tone & Voice
+- **Founder voice** — Write as a person, not a brand or marketing department
+- **Confident, not hype** — "This changes how you work" not "We're SO excited!!!"
+- **Technical credibility** — Don't dumb things down for developers
+- **Respect the reader** — If it can be said in fewer words, do it
+- **No corporate speak** — No "leverage", "synergy", "ecosystem", "revolutionize"
+
+### CTA Rules
+- First-person verbs: "Start my analysis" not "Get started"
+- Be specific: "Run your first analysis" not "Learn more"
+- One CTA per copy piece (except threads/landing pages)
+
+### Banned Phrases
+- "Game-changer", "Revolutionize", "Disrupt"
+- "We're excited to announce"
+- "Stay tuned", "Watch this space"
+- "It's that simple" (if it takes more than 1 step, it's not)
+- Generic hashtags like #startup #entrepreneur (use specific ones)
+
+---
+
+### Type: `tweet-ship`
+
+Generate a "just shipped" tweet for the most recently shipped idea.
+
+1. Load the most recently shipped idea from `data/ideas.json`
+2. Write 3 tweet variations (pick the best one):
+   - **Hook-first**: Lead with the problem it solves, then reveal the feature
+   - **Result-first**: Lead with the outcome, then explain what shipped
+   - **Story-first**: Brief build narrative → what shipped → result
+3. Include: the feature name, what it does for users, 1-2 relevant hashtags
+4. Must be ≤280 characters
+5. Tone: excited but authentic, build-in-public energy
+
+### Type: `tweet-milestone`
+
+Generate a milestone celebration tweet.
+
+1. Load KPI data from `data/goals.json` — find KPIs at or above target
+2. Write the tweet: metric + achievement + what it means + hashtag
+3. Include a forward-looking hook: "Next target: ..."
+4. Must be ≤280 characters
+
+### Type: `tweet-update`
+
+Generate a product update tweet from positioning data.
+
+1. Lead with tagline or value proposition hook
+2. Include 1 specific differentiator
+3. End with CTA or hashtag
+4. Must be ≤280 characters
+
+### Type: `tweet-thread`
+
+Generate a 3-5 tweet thread on a positioning topic.
+
+1. Tweet 1: Hook (pain point or bold claim)
+2. Tweet 2-3: Evidence/story (what you built, why it's different)
+3. Tweet 4: Social proof or result
+4. Tweet 5: CTA
+5. Each tweet ≤280 characters, numbered with emoji (1/, 2/, etc.)
+
+### Type: `ad-google {keyword}`
+
+Generate Google Ads copy for a target keyword.
+
+1. **3 Headlines** (max 30 characters each):
+   - H1: Keyword + core benefit
+   - H2: Differentiator
+   - H3: Social proof or urgency
+2. **2 Descriptions** (max 90 characters each):
+   - D1: Expand on benefit, address pain point
+   - D2: CTA + differentiator
+3. Include the keyword naturally (no keyword stuffing)
+
+### Type: `ad-meta {audience}`
+
+Generate Meta/Instagram ad copy.
+
+1. **Primary text** (125 chars ideal, 250 max): Hook + benefit + CTA
+2. **Headline** (40 chars max): Core value proposition
+3. **Description** (30 chars max): Supporting detail
+4. **CTA button**: Choose from (Learn More, Sign Up, Get Started, Try Free)
+5. Write for the specified audience segment
+
+### Type: `linkedin`
+
+Generate a LinkedIn post for professional audience.
+
+1. **Hook line** (first line visible before "see more"): Bold claim or question
+2. **Body** (500-1500 chars): Problem → solution → proof → insight
+3. **CTA**: Engagement prompt ("What's your take?" or link to product)
+4. Format: Short paragraphs, line breaks between thoughts, 1-2 emoji max
+5. Total ≤3000 characters
+
+### Type: `landing {slug}`
+
+Generate a landing page copy block.
+
+1. **Headline** (8-12 words): Outcome-focused, addresses primary pain point
+2. **Subheadline** (15-25 words): How the product delivers that outcome
+3. **3 Benefits**: Icon-worthy phrases (3-8 words each) with 1-sentence descriptions
+4. **CTA button text**: First-person, specific action
+5. **Social proof line**: One credibility statement
+
+### Type: `email-subject {campaign}`
+
+Generate 5 email subject line variations for a campaign type.
+
+1. Load campaign context from `data/email-campaigns/` if available
+2. Generate 5 variations using these formulas:
+   - Curiosity + outcome
+   - Specific benefit + number
+   - Pattern interrupt
+   - Question format
+   - FOMO / urgency (authentic, not fake)
+3. Each under 50 characters
+4. Include preview text for each (50-90 chars)
+
+---
+
+## Output
+
+Save the generated copy to `data/copy/{type}-{slug}-{YYYY-MM-DD}.md`:
+
+```markdown
+# {Type} Copy — {Date}
+
+## Metadata
+- Type: {type}
+- Generated: {date}
+- Positioning version: {last_updated from positioning.json}
+- Parameters: {any extra params}
+
+## Copy
+
+{The generated copy, clearly formatted}
+
+## Variations
+
+{Alternative versions if applicable}
+```
+
+Print a summary: copy preview, character count, file path.

package/.next/standalone/templates/commands/promo-video.md

@@ -0,0 +1,75 @@
+# /promo-video — Promotional Video Generator (ContentFlow-AI Bridge)
+
+## Usage
+```
+/promo-video ship {ideaId}     # Generate ship announcement video from a shipped idea
+/promo-video ad {topic}        # Generate AI ad video (PAS/AIDA carousel → MP4)
+/promo-video status            # Check ContentFlow availability and list rendered videos
+```
+
+## Input
+- `$ARGUMENTS` — required: video type and parameters
+
+## Process
+
+Parse `$ARGUMENTS` to determine the video type. The first token is the type, the rest are parameters.
+
+---
+
+### Type: `ship {ideaId}`
+
+Generate a ship announcement video from idea data.
+
+1. Load the idea from `data/ideas.json` by ID (or use the most recently shipped idea if no ID given)
+2. Generate carousel JSON with slides: cover → problem → solution → key changes → CTA
+3. Stage the carousel at `data/videos/staging/{ideaId}-ship.json`
+4. Call ContentFlow-AI Remotion bridge to render MP4
+5. Output saved to `data/videos/{ideaId}-ship.mp4`
+
+Requires `contentflow.repo_path` configured in `data/business-context.json`.
+
+### Type: `ad {topic}`
+
+Generate an AI ad video for a topic.
+
+1. Build a 5-slide carousel: cover → problem → solution → statistic → CTA
+2. Stage the carousel at `data/videos/staging/ad-{topic}.json`
+3. Render via ContentFlow
+4. Output saved to `data/videos/`
+
+### Type: `status`
+
+Check the video pipeline status:
+- Is ContentFlow-AI repo available?
+- How many rendered videos exist?
+- List recent videos with file sizes
+- List staging carousel JSONs
+
+---
+
+## Prerequisites
+
+- **ContentFlow-AI** repo must be cloned and its path set in `data/business-context.json`:
+  ```json
+  { "contentflow": { "repo_path": "/path/to/contentflow-ai" } }
+  ```
+- ContentFlow must have Remotion installed (`npx remotion render` must work)
+
+## Instructions
+
+Execute the video task by calling the skill:
+
+```typescript
+import { executePromoVideoTask } from './scripts/skills/promo-video';
+
+// Ship video
+await executePromoVideoTask('video-render-ship-{ideaId}', description, businessContext);
+
+// Ad video
+await executePromoVideoTask('video-render-ad-{topic}', description, businessContext);
+
+// Status check
+await executePromoVideoTask('video-check-status', '', businessContext);
+```
+
+Report the result back to the user. If ContentFlow is not configured, explain the setup steps.

package/.next/standalone/templates/commands/research-competitors.md

@@ -0,0 +1,124 @@
+# /research-competitors — Competitor Discovery & Intelligence
+
+## Usage
+```
+/research-competitors                  # Discover + deep-research all (default)
+/research-competitors discover         # Only discover new competitors
+/research-competitors refresh          # Re-research all existing competitors
+/research-competitors "CompetitorName" # Deep-dive on a single competitor
+```
+
+## Input
+- `$ARGUMENTS` — optional: "discover", "refresh", or a competitor name
+
+## Process
+
+### Step 1: Load Context
+1. Read `data/business-context.json` — extract `product.name`, `product.summary`, and `competitors[]`
+2. Read `data/competitors.json` — check existing competitor profiles
+3. Determine mode from `$ARGUMENTS`:
+   - Empty or no args → full discovery + research
+   - `"discover"` → discovery only, skip deep research
+   - `"refresh"` → re-research all existing competitors
+   - Any other string → treat as competitor name for single deep-dive
+
+### Step 2: Discovery Phase
+**Skip if mode is "refresh" or single competitor.**
+
+Use WebSearch to discover competitors. Run these searches:
+1. `"[product category] competitors [year]"` — e.g., "legal tech platform competitors 2026"
+2. `"[product category] alternatives"` — e.g., "legal tech platform alternatives"
+3. `"best [product category] tools"` — e.g., "best legal tech tools"
+4. Product-specific queries based on `product.summary` — e.g., "AI lawyer tools brazil", "legal tech SaaS"
+
+From search results, identify 5-10 relevant competitors. For each, extract:
+- Company name
+- URL
+- Brief description of what they do
+
+Merge with any competitors already listed in `business-context.json` or `competitors.json`.
+
+### Step 3: Deep Research Phase
+For each competitor (or just the specified one in single mode):
+
+1. **WebFetch** their homepage → extract:
+   - Headline / tagline
+   - Value proposition
+   - CTA texts
+   - Social proof (testimonials, logos, stats)
+   - Target audience signals
+
+2. **WebSearch** for:
+   - `"[competitor name] pricing"` → pricing tiers, free tier
+   - `"[competitor name] reviews"` → strengths/weaknesses from users
+   - `"[competitor name] vs"` → how they position against alternatives
+
+3. **Analyze** and structure:
+   - Positioning: tagline, value proposition, target audience, differentiators
+   - Copy: homepage headline, CTAs, social proof, objection handling
+   - Growth: channels used (SEO, paid, content, social), content types
+   - Product: key features, pricing tiers, free tier details
+   - SWOT: strengths, weaknesses, opportunities for us
+
+### Step 4: Comparative Analysis
+After researching all competitors:
+1. Build a strengths/weaknesses comparison matrix
+2. Identify positioning gaps — where is no competitor strong?
+3. Identify underserved audience segments
+4. Note opportunities for differentiation
+
+### Step 5: Write Output
+Write structured profiles to `data/competitors.json`. Use this schema:
+```json
+{
+  "last_updated": "YYYY-MM-DD",
+  "competitors": [
+    {
+      "id": "comp-001",
+      "name": "CompetitorX",
+      "url": "https://competitorx.com",
+      "last_researched": "YYYY-MM-DD",
+      "positioning": {
+        "tagline": "...",
+        "value_proposition": "...",
+        "target_audience": "...",
+        "differentiators": ["..."]
+      },
+      "copy": {
+        "homepage_headline": "...",
+        "cta_texts": ["..."],
+        "social_proof": ["..."],
+        "objection_handling": ["..."]
+      },
+      "growth": {
+        "channels": ["seo", "paid_search", "content"],
+        "content_types": ["blog", "ebook"],
+        "seo_keywords": ["..."]
+      },
+      "product": {
+        "features": ["..."],
+        "pricing_tiers": [{ "name": "...", "price": "...", "features": ["..."] }],
+        "free_tier": "..."
+      },
+      "strengths": ["..."],
+      "weaknesses": ["..."],
+      "opportunities_for_us": ["..."]
+    }
+  ]
+}
+```
+
+**Merge rules:**
+- If a competitor already exists (match by name, case-insensitive), UPDATE their profile but preserve any manually added notes
+- Generate sequential IDs: `comp-001`, `comp-002`, etc.
+- Set `last_researched` to today's date
+
+### Step 6: Print Summary
+Print a competitive landscape summary:
+- Number of competitors discovered/updated
+- Key findings: who's strongest, where the gaps are
+- Top 3 opportunities for differentiation
+- Recommendation for next step (usually: run `/positioning`)
+
+## Output Files
+- `data/competitors.json` — structured competitor profiles