vibebusiness 1.2.80 → 1.2.83

package/.next/standalone/templates/commands/email-marketing.md

@@ -0,0 +1,339 @@
+# /email-marketing — Email Marketing Setup & Campaign Generator
+
+## Usage
+```
+/email-marketing setup                # Guided Loops.so setup wizard
+/email-marketing verify               # Verify the email pipeline is working end-to-end
+/email-marketing campaign welcome     # Generate a welcome email campaign
+/email-marketing campaign onboarding  # Generate an onboarding drip email
+/email-marketing campaign feature-announcement  # New feature announcement
+/email-marketing campaign re-engagement         # Win-back inactive users
+/email-marketing campaign milestone             # User achievement celebration
+/email-marketing sequence {name}      # Design a multi-email drip sequence
+/email-marketing blast {slug}         # Draft a one-off announcement email
+```
+
+## Input
+- `$ARGUMENTS` — required: one of the modes above
+
+## Process
+
+Parse `$ARGUMENTS` to determine mode. The first word is the mode, the rest are arguments.
+
+## Copy Quality Framework
+
+When generating ANY email campaign, follow these rules. They override generic instincts.
+
+### Positioning Integration (Required)
+
+Before writing, load `data/positioning.json` and extract:
+- **Pain points** — Lead with one that matches the campaign's audience
+- **Messaging pillars** — Weave 1-2 into the body (Autonomous Intelligence, Full Lifecycle Closure, Built for Indie Hackers, Compounding Value)
+- **Objection handlers** — Preempt 1 relevant objection (e.g., "not a ChatGPT wrapper", "can I trust AI?")
+- **Social proof** — Include 1 credibility anchor (user count, autonomous shipping proof, market analysis)
+- **CTA bank** — Pull CTA text from positioning rather than inventing generic ones
+- **Headlines** — Use copy_bank headlines as inspiration for subject lines
+
+### Subject Lines
+
+Write 3 variations using these formulas:
+1. **Curiosity + outcome**: "The 1 thing that changes how you decide what to build"
+2. **Specific benefit**: "Your first business analysis in 60 seconds"
+3. **Pattern interrupt**: "Every dev tool waits for you. This one doesn't."
+
+Rules:
+- Under 50 characters (avoid mobile truncation)
+- No "Welcome to [Product]!" or "We're excited!"
+- Test: would YOU open this from an unknown sender?
+
+### Opening Lines
+
+NEVER use:
+- "Hey there," / "Hi there," / "Hello,"
+- "Welcome to [Product]!"
+- "We're excited to have you!"
+- "Hope this email finds you well"
+
+INSTEAD, use one of these patterns:
+- **Pain-point hook**: "You signed up because you're tired of guessing what to build next."
+- **Outcome statement**: "One command. Your entire business strategy. That's what you just unlocked."
+- **Observation**: "Most dev tools help you write code faster. None of them tell you what code to write."
+- **Direct + warm**: "You're in. Here's the short version of what happens next."
+
+### Body Copy Rules
+
+- **Length**: 80-150 words for welcome; 150-250 for educational/onboarding
+- **Paragraphs**: Max 2-3 sentences each
+- **One idea per email** — don't feature-dump
+- **Benefits over features**: "decides what to ship next" not "uses AI analysis"
+- **Bold key phrases** for scannability
+- **Address one objection** naturally (not as a FAQ — weave it in)
+- **Include social proof** inline, not as a separate section
+
+### CTA Rules
+
+- **Primary CTA**: One clear action button. First-person verb: "Start my analysis" not "Get started"
+- **Secondary CTA**: One reply/engagement prompt: "Reply and tell me..."
+- **No vague CTAs**: "Get Started" is banned. Be specific: "Run your first analysis", "See what it finds"
+- **Place primary CTA after the core benefit**, not at the very end
+
+### Preview Text
+
+Formula: [Pain point or hook] + [time/effort] + [outcome]
+- "Stop guessing what to build. 60 seconds to your first strategy."
+- "Your AI analyst just found 12 ideas you missed."
+
+### Tone
+
+- **Founder voice** — write as a person, not a brand
+- **Confident, not hype** — "This will change how you work" not "We're SO excited!!!"
+- **Respect the reader's time** — if it can be said in fewer words, do it
+- **Technical credibility** — don't dumb things down for developers
+- **CLI-native language** — reference terminal, commands, repos — not "dashboards" or "platforms"
+
+---
+
+### Mode: `setup`
+
+Interactive Loops.so setup wizard.
+
+1. **Check API Key**: Verify `LOOPS_API_KEY` is set in the environment
+   - If not set: print instructions to add it to `.env` and stop
+   - If set: call `GET /api/v1/api-key` to verify it's valid
+
+2. **Audit Current State**:
+   - List existing mailing lists via the Loops API
+   - List existing contact properties
+   - List existing transactional email templates
+   - Print a summary of what's already configured
+
+3. **Set Up Contact Properties**: Create recommended properties if they don't exist:
+   - `source` (string) — where the contact came from (e.g., "website", "twitter", "producthunt")
+   - `userGroup` (string) — segment (e.g., "beta_tester", "waitlist", "customer")
+   - `plan` (string) — pricing plan (e.g., "free", "pro", "enterprise")
+
+4. **Configure KPI Adapter**: Read `data/business-context.json` and check if a `loops` KPI adapter is configured. If not, add one:
+   ```json
+   {
+     "id": "loops",
+     "type": "loops",
+     "field_mapping": {
+       "kpi-waitlist-signups": "total_contacts"
+     }
+   }
+   ```
+
+5. **Print Dashboard Setup Checklist**: After the API setup steps above, print a clear checklist of manual steps the user must complete in the Loops dashboard (the Loops API cannot create templates or automations programmatically):
+
+   ```
+   ## Manual Loops Dashboard Setup Required
+
+   The Loops API cannot create templates or automations programmatically.
+   Complete these steps in the Loops dashboard (https://app.loops.so):
+
+   ### 1. Create Mailing List
+   - Go to: Audience → Lists → Create List
+   - Name: "Beta Waitlist"
+
+   ### 2. Create Transactional Email Template
+   - Go to: Transactional → New Transactional Email
+   - Name: "Welcome — Waitlist"
+   - Copy subject/body from: data/email-campaigns/welcome-2026-02-20.md
+   - Set reply-to: your personal email
+
+   ### 3. Create Automation
+   - Go to: Automations → New Automation
+   - Trigger: Event → "waitlist_joined"
+   - Action: Send transactional email → "Welcome — Waitlist"
+   - Activate the automation
+
+   ### 4. Verify Pipeline
+   - Run: /email-marketing verify
+   ```
+
+6. **Print Summary**: What was set up, what was already configured, next steps (run `/email-marketing verify` to test the pipeline).
+
+---
+
+### Mode: `verify`
+
+Verify that the full email pipeline (API → mailing lists → templates → automations) is working.
+
+1. **Verify API Key**: Call `GET /api/v1/api-key` — print PASS or FAIL
+2. **Check Mailing Lists**: Call the Loops API to list mailing lists — print PASS if at least 1 exists, FAIL with instructions otherwise
+3. **Check Transactional Templates**: Call the Loops API to list transactional email templates — print PASS if at least 1 exists, FAIL with instructions otherwise
+4. **Test Pipeline End-to-End**:
+   - Create a test contact with email `test-verify-{timestamp}@example.com`
+   - Set properties: `source: "verify_test"`, `userGroup: "test"`
+   - Send a `waitlist_joined` event for that contact
+   - Print PASS if both API calls succeed
+5. **Print Results Checklist**:
+   ```
+   ## Email Pipeline Verification
+
+   [PASS/FAIL] API Key — valid (team: {teamName})
+   [PASS/FAIL] Mailing Lists — {count} found
+   [PASS/FAIL] Transactional Templates — {count} found
+   [PASS/FAIL] Test Event — waitlist_joined sent to test contact
+
+   {If all pass:}
+   All checks passed! Your email pipeline is ready.
+   Submit a real email on your waitlist form to confirm delivery.
+
+   {If any fail:}
+   Some checks failed. Complete the manual setup steps above, then re-run /email-marketing verify.
+   ```
+
+---
+
+### Mode: `campaign {type}`
+
+Generate an email campaign draft using positioning data and business context.
+
+Supported types: `welcome`, `onboarding`, `feature-announcement`, `re-engagement`, `milestone`
+
+1. **Load Context**:
+   - Read `data/positioning.json` — headlines, CTAs, pain points, objection handlers, brand voice
+   - Read `data/business-context.json` — product info, audience, value proposition
+   - Read `data/goals.json` — current business goals for relevance
+
+2. **Generate Campaign** based on type:
+
+   **`welcome`** — First email after waitlist/signup:
+   - Subject line (3 variations using formulas above)
+   - Preview text (using formula above)
+   - Body structure:
+     1. Pain-point opening (from positioning pain_points — lead with "decision paralysis")
+     2. One-sentence value prop (what they signed up for, in bold)
+     3. How it's different (vs Cursor/Copilot — the brain/hands distinction)
+     4. What to expect (2-3 bullet points: early access timing, build-in-public updates, no spam)
+     5. Engagement CTA: "Reply and tell me: what's the one thing you wish AI could handle?"
+     6. Founder sign-off with P.S. (address one objection: BYOK/privacy, cost, or trust)
+   - Tone: founder letter, personal, confident — NOT corporate welcome
+   - Include personalization tokens: `{{source}}` (no `{{firstName}}` — waitlist form collects email only)
+   - DO NOT include: feature lists, setup instructions, or multiple CTAs
+
+   **`onboarding`** — Guide new users to first value:
+   - Subject line (3 variations)
+   - Body: acknowledge signup → one quick-win action → expected outcome → CTA to first action
+   - Focus on time-to-value: "60 seconds to your first analysis"
+   - Include personalization: `{{source}}`
+
+   **`feature-announcement`** — New feature shipped:
+   - Subject line (3 variations)
+   - Body: what's new → why it matters → how to use it → CTA to try it
+   - Pull differentiators from positioning data
+   - If $ARGUMENTS includes an idea ID, load that idea for specific feature details
+
+   **`re-engagement`** — Win back inactive users:
+   - Subject line (3 variations)
+   - Body: we miss you → what's new since they left → special offer/incentive → CTA
+   - Use objection handlers from positioning to address likely reasons for leaving
+
+   **`milestone`** — Celebrate user achievements:
+   - Subject line (3 variations)
+   - Body: congratulations → what they achieved → what's next → CTA to share/upgrade
+   - Keep it short and celebratory
+
+3. **Write Output**: Save to `data/email-campaigns/{type}-{YYYY-MM-DD}.md` as structured markdown:
+   ```markdown
+   # {Type} Email Campaign — {Date}
+
+   ## Metadata
+   - Type: {type}
+   - Generated: {date}
+   - Positioning version: {last_updated from positioning.json}
+
+   ## Subject Lines
+   1. {subject1}
+   2. {subject2}
+   3. {subject3}
+
+   ## Preview Text
+   {preview}
+
+   ## Body
+
+   {full email body in markdown}
+
+   ## Loops Integration Notes
+   - Suggested event trigger: {event_name}
+   - Recommended mailing list: {list_name}
+   - Personalization tokens used: {list}
+   ```
+
+4. **Print Summary**: Preview of subject lines, word count, file path, suggestion to set up in Loops dashboard.
+
+---
+
+### Mode: `sequence {name}`
+
+Design a multi-email drip sequence.
+
+1. **Load Context**: Same as campaign mode — positioning, business context, goals.
+
+2. **Design Sequence**:
+   - Generate 3-5 emails with recommended timing (e.g., Day 0, Day 2, Day 5, Day 10, Day 14)
+   - Each email has: subject line, preview text, body, CTA
+   - Map a Loops event name to trigger each email
+   - Ensure narrative arc: introduce → educate → demonstrate value → convert → reinforce
+
+3. **Write Output**: Save to `data/email-campaigns/sequences/{name}.md`:
+   ```markdown
+   # {Name} Email Sequence
+
+   ## Overview
+   - Emails: {count}
+   - Duration: {total days}
+   - Goal: {sequence goal}
+   - Trigger event: {initial trigger}
+
+   ## Email 1: {title} (Day 0)
+   **Trigger:** {event_name}
+   **Subject:** {subject}
+   **Preview:** {preview}
+
+   {body}
+
+   ---
+
+   ## Email 2: {title} (Day 2)
+   ...
+   ```
+
+4. **Print Summary**: Sequence overview, timing chart, event names to configure in Loops.
+
+---
+
+### Mode: `blast {slug}`
+
+Draft a one-off announcement email.
+
+1. **Load Context**: Positioning data, business context. If slug matches an idea ID in `data/ideas.json`, load that idea for specific details.
+
+2. **Generate Email**:
+   - Subject line (3 variations)
+   - Preview text
+   - Body: announcement → details → why it matters → CTA
+   - Keep it concise — one-off emails should be scannable
+
+3. **Write Output**: Save to `data/email-campaigns/blasts/{slug}.md`
+
+4. **Print Summary**: Preview of subject lines, file path.
+
+---
+
+## Directory Structure
+
+Ensure these directories exist before writing (create if needed):
+```
+data/email-campaigns/
+├── sequences/
+└── blasts/
+```
+
+## Output Files
+- `data/email-campaigns/{type}-{date}.md` — campaign drafts
+- `data/email-campaigns/sequences/{name}.md` — drip sequences
+- `data/email-campaigns/blasts/{slug}.md` — one-off emails
+- `data/business-context.json` — updated with Loops KPI adapter (setup mode only)

package/.next/standalone/templates/commands/growth-audit.md

@@ -0,0 +1,85 @@
+# /growth-audit — Growth Channel Audit
+
+## Usage
+```
+/growth-audit                # Full channel comparison (default)
+/growth-audit seo            # Deep-dive on SEO channel
+/growth-audit paid           # Deep-dive on paid acquisition
+/growth-audit content        # Deep-dive on content marketing
+/growth-audit referral       # Deep-dive on referral/partnerships
+```
+
+## Input
+- `$ARGUMENTS` — optional: specific channel to deep-dive
+
+## Process
+
+### Step 1: Load Context
+1. Read `data/competitors.json` — all competitor growth channel data
+2. Read `data/business-context.json` — our current funnels, channels, KPIs
+3. Read `data/ideas.json` — existing growth ideas (to avoid duplicates)
+
+### Step 2: Map Channel Landscape
+If no competitor data exists, run quick WebSearch queries:
+- `"[product category] growth channels"`
+- `"[product category] marketing strategy"`
+- `"how to grow [product category] startup"`
+
+Build a channel comparison matrix:
+
+| Channel | Us | Competitor A | Competitor B | Competitor C |
+|---------|-----|-------------|-------------|-------------|
+| SEO/Blog | ... | ... | ... | ... |
+| Paid Search | ... | ... | ... | ... |
+| Social Media | ... | ... | ... | ... |
+| Content Marketing | ... | ... | ... | ... |
+| Email/Newsletter | ... | ... | ... | ... |
+| Referral Program | ... | ... | ... | ... |
+| Partnerships | ... | ... | ... | ... |
+| Community | ... | ... | ... | ... |
+
+For each channel, note: active/inactive, estimated investment level, content frequency.
+
+### Step 3: Gap Analysis
+Identify:
+1. **Channels competitors use that we don't** — potential opportunities
+2. **Channels we use that competitors don't** — potential advantages
+3. **Channels everyone uses** — table stakes, must maintain
+4. **Channels nobody uses** — either untapped opportunity or proven dead-end
+
+### Step 4: Channel Deep-Dive
+If `$ARGUMENTS` specifies a channel, or for the top 3 opportunity channels:
+
+Run WebSearch for best practices:
+- `"[channel] strategy for [product category] [year]"`
+- `"[channel] benchmarks SaaS [year]"`
+
+For each channel, estimate:
+- **Effort**: How much work to start? (1-10)
+- **Time to results**: Weeks/months until impact
+- **Impact potential**: Revenue/traffic uplift estimate
+- **Prerequisites**: What needs to exist first? (e.g., blog infrastructure for content)
+
+### Step 5: Generate Growth Experiments
+Create ranked growth experiments as ideas in `data/ideas.json`:
+
+For each recommended experiment:
+- Title: specific, actionable (e.g., "Launch SEO blog targeting [keyword cluster]")
+- Category: "growth"
+- Priority: based on effort/impact ratio
+- Implementation plan: step-by-step
+- Success metrics: measurable outcomes
+- Tags: include channel name
+
+Generate 3-5 experiments, ranked by estimated ROI.
+
+### Step 6: Output
+Print:
+- Channel comparison matrix
+- Gap analysis summary
+- Top 3 growth channel recommendations with rationale
+- Experiments generated (linked to ideas.json)
+- Recommendation for next step
+
+## Output Files
+- `data/ideas.json` — new growth experiment ideas

package/.next/standalone/templates/commands/launch-campaign.md

@@ -0,0 +1,84 @@
+# /launch-campaign — Multi-Channel Marketing Campaign Orchestrator
+
+## Usage
+```
+/launch-campaign ship {ideaId}       # Full ship campaign
+/launch-campaign milestone {kpiId}   # Milestone celebration campaign
+/launch-campaign status              # List active/completed campaigns
+```
+
+## Input
+- `$ARGUMENTS` — required: campaign type and parameters
+
+## Process
+
+Parse `$ARGUMENTS` to determine the campaign type.
+
+### Type: `ship {ideaId}`
+
+Orchestrate a full ship announcement campaign across all configured channels.
+
+1. **Load Context**:
+   - Read `data/ideas.json` — find the shipped idea by ID
+   - Read `data/positioning.json` — for copy quality
+   - Read `data/social.json` — check if X is configured
+   - Check if Loops email is configured (LOOPS_API_KEY in env)
+   - Check `data/business-context.json` — ContentFlow config
+
+2. **Generate Campaign Plan**:
+   Based on what channels are configured, queue these sub-tasks in TODO.md:
+   - `generate-visual-{ideaId}` — Ship card PNG (if not already generated)
+   - `video-render-ship-{ideaId}` — Ship video (if ContentFlow configured)
+   - `copy-tweet-ship` — Generate positioning-driven tweet copy
+   - `social-draft-ship-visual` — Create tweet draft with media (after card/video ready)
+   - `email-campaign-feature-announcement` — Email announcement draft
+   - `copy-social-linkedin` — LinkedIn post copy
+
+3. **Write Campaign State**: Save to `data/campaigns/{ideaId}-{YYYY-MM-DD}.json`:
+   ```json
+   {
+     "id": "campaign-{ideaId}-{date}",
+     "type": "ship",
+     "idea_id": "{ideaId}",
+     "created_at": "{ISO date}",
+     "status": "active",
+     "sub_tasks": [
+       { "task_id": "generate-visual-{ideaId}", "status": "queued" },
+       { "task_id": "video-render-ship-{ideaId}", "status": "queued" },
+       { "task_id": "copy-tweet-ship", "status": "queued" },
+       { "task_id": "social-draft-ship-visual", "status": "queued" },
+       { "task_id": "email-campaign-feature-announcement", "status": "queued" },
+       { "task_id": "copy-social-linkedin", "status": "queued" }
+     ],
+     "channels": ["x", "email", "linkedin"]
+   }
+   ```
+
+4. **Add Sub-Tasks to TODO.md**: Write each sub-task as a high-priority TODO item.
+   Sub-tasks execute on subsequent heartbeats (natural pacing, not all at once).
+
+5. **Print Campaign Summary**: What was queued, which channels, estimated timeline.
+
+### Type: `milestone {kpiId}`
+
+Orchestrate a milestone celebration campaign.
+
+1. **Load KPI Data**: Find the KPI in `data/goals.json`
+2. **Queue Sub-Tasks**:
+   - `copy-tweet-milestone` — Milestone tweet copy
+   - `social-draft-milestone` — Tweet draft
+   - `email-campaign-milestone` — Celebration email
+3. **Save Campaign State**: Same format as ship, but type "milestone"
+
+### Type: `status`
+
+List all campaigns and their sub-task completion status.
+
+1. Read all files from `data/campaigns/`
+2. For each campaign, check sub-task completion (cross-reference with TODO.md)
+3. Print summary table
+
+## Output
+- Campaign state: `data/campaigns/{id}.json`
+- Sub-tasks: Added to `TODO.md` as high-priority items
+- Print: Campaign summary with channel list and task queue

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

@@ -0,0 +1,147 @@
+# /manage — Interactive Data Editor
+
+## Usage
+```
+/manage show me all ideas with priority=critical
+/manage change the priority of idea-emergency-001 to high
+/manage add a new idea: "Add telemetry dashboard for command usage"
+/manage move idea-003 to approved stage
+/manage update our MRR to 5000 in business context
+/manage show ideas stuck in inbox for more than 7 days
+/manage delete hypothesis hyp-005
+/manage list all goals that are behind
+```
+
+## Input
+- `$ARGUMENTS` — **required**: natural-language request describing what to query, create, update, or delete
+
+## Data File Map
+
+| File | Structure | Contains |
+|------|-----------|----------|
+| `data/ideas.json` | `{ ideas: BusinessIdea[] }` | Innovation pipeline |
+| `data/goals.json` | `{ goals: BusinessGoal[] }` | Business goals + KPIs |
+| `data/hypotheses.json` | `{ hypotheses: BusinessHypothesis[] }` | Testable hypotheses |
+| `data/business-context.json` | `BusinessConfig` | Product info, funnels, monetization |
+| `data/config.json` | `AnalystConfig` | Repos, schedules, autonomy settings |
+| `data/competitors.json` | `{ competitors[], last_updated }` | Competitor intelligence |
+| `data/positioning.json` | `PositioningData` | Brand positioning & copy bank |
+| `data/sessions.json` | `{ sessions: AnalysisSession[] }` | Analysis session history |
+
+## Schema Reference (Valid Enum Values)
+
+```
+Priority:          critical | high | medium | low
+Stage:             inbox | under_review | approved | in_progress | testing | shipped | deferred | rejected | rolled_back
+Category:          product | ux_design | growth | performance | tech_debt | security | infrastructure | content | analytics | integration
+Effort (size):     xs | s | m | l | xl
+Impact (size):     xs | s | m | l | xl
+GoalCategory:      acquisition | activation | retention | revenue | referral
+GoalStatus:        on_track | at_risk | behind | achieved
+HypothesisStatus:  stated | testing | validated | invalidated | deferred
+SourceType:        codebase_analysis | metrics_review | market_research | seo_audit | manual
+KPISource:         manual | rest_api | posthog | firestore | stripe | whatsapp
+KPIDirection:      higher_is_better | lower_is_better
+```
+
+## Process
+
+### Step 1: Parse Request
+Analyze `$ARGUMENTS` to determine:
+- **Intent**: query, create, update, delete, or bulk operation
+- **Entity type**: idea, goal, hypothesis, business-context, config, competitor, positioning, session
+- **Target**: specific ID (e.g., `idea-emergency-001`) or filter criteria (e.g., `priority=critical`)
+- **Fields to change**: which fields and their new values
+
+### Step 2: Load State
+Read **only** the data file(s) needed for this operation. Do NOT read all files.
+
+- Idea operations → `data/ideas.json`
+- Goal operations → `data/goals.json`
+- Hypothesis operations → `data/hypotheses.json`
+- Business context → `data/business-context.json`
+- Config changes → `data/config.json`
+- Competitor operations → `data/competitors.json`
+- Positioning operations → `data/positioning.json`
+- Session queries → `data/sessions.json`
+
+### Step 3: Execute
+
+#### For **queries** (show, list, find, count):
+- Filter the data based on the request criteria
+- Format results as a readable table or summary
+- Include relevant fields (id, title, stage, priority at minimum for ideas)
+- For time-based queries (e.g., "stuck in inbox for 7 days"), compare `created_at` or `updated_at` against current date
+
+#### For **create** (add, new, create):
+- Generate an ID following the existing pattern:
+  - Ideas: `idea-[slug]-NNN` (e.g., `idea-telemetry-001`)
+  - Goals: `goal-NNN` (e.g., `goal-005`)
+  - Hypotheses: `hyp-NNN` (e.g., `hyp-010`)
+- Set `created_at` and `updated_at` to current ISO timestamp
+- Set defaults for required fields not specified by the user:
+  - Ideas: `stage: "inbox"`, `priority: "medium"`, `source: { type: "manual" }`
+  - Hypotheses: `status: "stated"`, `priority: "medium"`
+  - Goals: `status: "on_track"`, `kpis: []`
+- Append to the appropriate array in the JSON file
+- Show the full created entity
+
+#### For **update** (change, set, move, update):
+- Find the entity by ID (exact match)
+- If ID is ambiguous or not found, search by title substring and ask for confirmation
+- Record the **before** value of changed fields
+- Apply the changes
+- Set `updated_at` to current ISO timestamp
+- Show a before/after diff
+
+#### For **delete** (remove, delete):
+- Find the entity by ID
+- Show what will be deleted and ask for confirmation before proceeding
+- Remove the entity from the array
+- Show confirmation of deletion
+
+#### For **bulk operations** (e.g., "move all inbox ideas older than 30 days to deferred"):
+- Show all entities that match the criteria
+- Ask for confirmation before applying changes
+- Apply changes to all matching entities
+- Show summary of changes
+
+### Step 4: Validate
+Before writing any changes, verify:
+1. **Enum values are valid** — check against the Schema Reference above
+2. **Required fields are present** — id, title, created_at, updated_at at minimum
+3. **IDs are unique** — no duplicate IDs in the array
+4. **Array structure preserved** — the file still has the correct top-level structure (e.g., `{ "ideas": [...] }`)
+5. **Timestamps are ISO 8601** — format: `2026-02-16T12:00:00Z`
+
+If validation fails, report the error and do NOT write the file.
+
+### Step 5: Report
+After executing, print a summary:
+
+**For queries:**
+```
+📋 Found N [entities] matching "[criteria]"
+[formatted table or list]
+```
+
+**For mutations (create/update/delete):**
+```
+✅ [Action] completed
+
+Entity: [id]
+File: data/[file].json
+
+[Before → After diff for changed fields]
+```
+
+## Safety Rules
+1. **Always read before writing** — never modify a file without reading it first
+2. **Preserve structure** — maintain the JSON array wrapper and all unchanged fields
+3. **Validate enums** — reject invalid enum values with a helpful error message listing valid options
+4. **Update timestamps** — set `updated_at` on every mutation
+5. **Confirm destructive actions** — ask before delete or bulk operations
+6. **One file at a time** — avoid writing multiple data files in a single operation unless explicitly requested
+
+## Output Files
+- The specific `data/*.json` file(s) modified by the operation