reflexive 0.1.0

package/docs/HN-LAUNCH-PLAN-V2.md

@@ -0,0 +1,631 @@
+# Reflexive: The Ultimate Hacker News Launch Plan
+
+## Part I: The Research Foundation
+
+### Analysis of Successful HN Dev Tool Launches (2024-2026)
+
+Based on analysis of top-performing Show HN posts in the AI/Claude/dev-tools categories, patterns emerge that predict success.
+
+#### High-Engagement Post Characteristics
+
+| Category | Avg Points | Key Success Factors |
+|----------|------------|---------------------|
+| Claude-related tools | 175-600+ | Novel applications, "I built X" authenticity, clear utility |
+| MCP servers/integrations | 100-350 | Specific use case, immediate try-ability, Anthropic ecosystem |
+| AI debugging/vibe coding | 100-250 | "Finally solves X" framing, video demos, emergent behavior |
+| Novel dev paradigms | 200-500+ | "New way of thinking," paradigm shift language, founder story |
+
+#### Title Formula Analysis
+
+**Top performers follow this pattern:**
+```
+Show HN: [Tool Name] - [Provocative One-liner that challenges assumptions]
+```
+
+**Winning characteristics:**
+- Under 80 characters
+- Contains a "wait, what?" moment
+- Implies capability without overselling
+- Technical specificity (Node.js, V8, etc.) adds credibility
+
+**Examples that worked:**
+- "Browser MCP - Automate browser using Cursor, Claude, VS Code" (616 pts)
+- "I used Claude Code to discover connections between 100 books" (524 pts)
+- "Time travel debugging AI for more reliable vibe coding" (129 pts)
+
+#### The HN Audience Psychology
+
+**What resonates:**
+1. **Novel paradigms** - "A new type of computing" lands better than "a better X"
+2. **Technical authenticity** - Show, don't tell. Code > claims.
+3. **Scratched-itch stories** - "I built this because I needed it"
+4. **Emergent behaviors** - Unexpected capabilities that emerged
+5. **Demo magic** - Moments where the tool does something surprising
+6. **Philosophical implications** - What does this mean for the future?
+
+**What triggers skepticism:**
+- "Revolutionary" or "game-changing" language
+- Vague promises without concrete demos
+- Overpolished marketing speak
+- Lack of technical depth in comments
+- No video/GIF proof
+
+#### Optimal Posting Analysis
+
+**Pick one of these two and commit:**
+
+##### Option A: "Classic" Visibility Window
+- **When:** Tue–Thu morning, 8:00–10:00 AM ET (5:00–7:00 AM PT)
+- **Pros:** Consistent attention; aligns with long-running folk wisdom
+- **Cons:** High competition from other launches
+
+##### Option B: "Low Competition" Window
+- **When:** 12:00–1:00 AM ET (9:00–10:00 PM PT)
+- **Pros:** Analysis suggests disproportionate comments/votes in this slot due to lower competition
+- **Cons:** You must be awake and intensely responsive for 2–3 hours
+
+**Recommendation:** If you're willing to be intensely present late night, choose **Option B** because your post benefits from high comment velocity (skeptic questions early = opportunity to demonstrate depth). If you want safer ergonomics, choose **Option A**.
+
+**Engagement decay curve:**
+- 0-2 hours: CRITICAL - responses must be <5 min (not 10)
+- 2-6 hours: Important - maintain presence
+- 6-24 hours: Follow-up on new comments
+- 24+ hours: Long-tail engagement
+
+---
+
+## Part II: The Story That Must Be Told
+
+### The Buried Lead (DO NOT BURY THIS)
+
+**IMPORTANT:** Do not say "new type of computing" in the submission. Let commenters say it for you. Instead, repeatedly describe the primitive:
+
+> "Agent loop + tools + process lifecycle + debugger + event triggers."
+
+Imply the paradigm shift. Don't declare it.
+
+#### The Dream
+
+> "Forever I've wanted AI embedded in the programming language itself. Catch an exception - run a prompt. API failure - research the docs, scan for schema changes, patch the response."
+
+This is the opening hook. It's not about features. It's about a vision that every developer has secretly harbored.
+
+#### The Discovery
+
+> "Claude Agent SDK IS Claude Code. Same MAX credentials. Same ./claude sessions. You can build your own Claude Code with complete control."
+
+The realization that democratizes AI agents. Not using Claude Code - BEING Claude Code.
+
+#### The Experiment
+
+> "What if I went one layer deeper - embedded Claude inside the running application itself, with total state awareness, full debugging MCP, 30+ tools aimed inward throughout the lifecycle?"
+
+The key insight: go from watching your app to living inside it.
+
+#### The Magic Moment
+
+**This is your demo:**
+
+> Started with an empty file. App immediately exited with code 1. Agent asked if I wanted to address it. I said yes.
+>
+> Minutes later - working webserver.
+>
+> AND THE AGENT KEPT WORKING AFTER I WALKED AWAY. It used curl to test, explained its choices, justified keeping the app running by making it a webserver.
+
+**The emergent behavior is the story.** The agent didn't just fix the problem - it thought about the problem, tested the solution, and documented its reasoning. Autonomously.
+
+#### The Iron Man Suit
+
+> "It really flew - Claude Code agent loop, prompting complexity, task delegator, planner, web researcher - plus its harness, its puppet strings were PIDs and internal state."
+
+The metaphor that sells: this is the Iron Man suit for developers. All the power of Claude Code, but YOU control the suit.
+
+#### The Culmination: Autonomous Hack Response
+
+**This is your viral moment:**
+
+> Placed a breakpoint before an API response. Modified one value to say "Customer.Hacked." Manually resumed execution.
+>
+> Then... half a dozen errors in the log. An edit to a file. A restart of the app. And a looooong post-mortem on the hack that took place.
+>
+> The agent had detected the anomaly, AUTONOMOUSLY isolated the vulnerable code, disabled it with a warning, and written a security post-mortem.
+
+**The agent didn't wait for instructions. It protected the application.**
+
+This is the "holy shit" moment that will get shared.
+
+---
+
+## Part III: The Perfect Post
+
+### Title Options (Ranked by Predicted Performance)
+
+**Tier 1: Paradigm Shift Framing**
+
+1. **Show HN: I embedded Claude inside a running app. It kept working after I walked away.**
+   - Predicted points: 250-400
+   - Hook: "kept working after I walked away" - emergent behavior
+   - Risk: Might sound like exaggeration (mitigate in first comment)
+
+2. **Show HN: Reflexive - What if your running app could debug itself with Claude?**
+   - Predicted points: 200-350
+   - Hook: "debug itself" challenges assumptions
+   - Safe bet with clear utility framing
+
+3. **Show HN: Start with an empty file. Tell Claude what to build. Watch your app evolve.**
+   - Predicted points: 200-300
+   - Hook: Complete dev cycle in one sentence
+   - Appeals to vibe coding crowd
+
+**Tier 2: Technical Credibility**
+
+4. **Show HN: AI agent with V8 debugger access - it set a breakpoint and caught a hack autonomously**
+   - Predicted points: 150-250
+   - Hook: "caught a hack autonomously" - dramatic emergent behavior
+   - Technical depth for skeptics
+
+5. **Show HN: Claude Agent SDK + your running Node.js process = AI that sees logs, sets breakpoints, patches code**
+   - Predicted points: 150-250
+   - Hook: Concrete capability list
+   - Builds on Claude/Anthropic ecosystem familiarity
+
+**Tier 3: Feature-Forward**
+
+6. **Show HN: npx reflexive --write app.js - now chat with your running app**
+   - Predicted points: 100-200
+   - Hook: Immediate try-ability
+   - May undersell the paradigm shift
+
+### The Post Body
+
+```markdown
+Show HN: I embedded Claude inside a running app. It kept working after I walked away.
+
+https://github.com/[username]/reflexive
+
+Forever I wanted AI embedded in the programming language itself - catch an exception, run a prompt. API failure? Research the docs, scan for schema changes, patch the response.
+
+Then I discovered: Claude Agent SDK IS Claude Code. Same credentials. Same sessions. You can build your own Claude Code with complete control.
+
+So I went one layer deeper. What if Claude lived INSIDE the running application? Total state awareness. V8 debugger access. 30+ MCP tools aimed inward throughout the lifecycle.
+
+**The Magic Moment:**
+Started with an empty file. Ran `npx reflexive --write app.js`. App exited with code 1. Agent asked if I wanted to address it. I said yes.
+
+Minutes later - working webserver. And the agent kept working after I walked away. It used curl to test its own creation, documented its choices, explained why it kept the app running.
+
+**The Holy Shit Moment:**
+I set a breakpoint, modified a value to say "Customer.Hacked", and resumed. The agent detected the anomaly, AUTONOMOUSLY isolated the vulnerable code, disabled it with a warning, and wrote a post-mortem. No prompt from me.
+
+Agent loop + process lifecycle + debugger + event triggers. All in one primitive.
+
+  npx reflexive --write --debug app.js
+  # Open http://localhost:3099
+  # Chat with your running application
+
+Features:
+- Watch triggers: Set log patterns, agent auto-investigates when they appear
+- Real V8 breakpoints with prompt attachments
+- Modify runtime state while paused
+- File editing + process restart in the conversation
+- Works with any Node.js app (CLI mode) or embed in your code (library mode)
+
+Two dependencies. ~1500 lines. No build step.
+
+Video demo: [link]
+```
+
+### The First Comment (Post Immediately)
+
+```markdown
+Hey HN! The founder story:
+
+I'm a "vibe coder" - IDE in one window, Claude Code in another, server running in a third. I realized Claude Agent SDK is literally Claude Code with the safety rails removed. You can build your own.
+
+So I asked: what if the AI didn't just see my code, but lived INSIDE my running app? What if it could see every log, set real breakpoints, modify state, and respond to events?
+
+The emergent behaviors surprised me:
+- Started from empty file, agent figured out I needed a webserver
+- Agent continued working AFTER I stopped prompting (used curl to test its own work!)
+- When I injected "Customer.Hacked" into runtime state, it autonomously detected, isolated, and documented the vulnerability
+
+The breakpoint + prompt combo is my favorite feature. Set a breakpoint, attach a prompt like "analyze this request and explain any anomalies", and let the agent pause execution, inspect state, and resume when it's satisfied.
+
+**Questions I'd love feedback on:**
+- Is autonomous file editing scary or exciting? (behind --write flag)
+- Would you use watch triggers in production (read-only mode)?
+- What MCP tools would you add?
+
+Happy to go deep on any technical questions. The whole thing is ~1500 lines in one file - intentionally simple to fork and modify.
+```
+
+---
+
+## Part IV: Quantitative Predictions
+
+### Expected Performance (With Confidence Intervals)
+
+Based on comparable launches and Reflexive's unique positioning:
+
+| Metric | Conservative (25th %ile) | Expected (50th %ile) | Optimistic (75th %ile) |
+|--------|--------------------------|----------------------|------------------------|
+| Points | 100 | 200 | 400+ |
+| Comments | 40 | 80 | 150+ |
+| GitHub stars (week 1) | 200 | 600 | 1500+ |
+| npm downloads (week 1) | 300 | 1000 | 3000+ |
+
+### Factors That Could Push to Optimistic
+
+1. **Video captures the "empty file to autonomous hack response" journey** - Visual proof of emergent behavior
+2. **Quick response time in comments** - Maintains momentum
+3. **Technical depth in answers** - Builds credibility
+4. **No major competing news that day** - Clean news cycle
+5. **Early organic sharing** - Gets picked up by AI/dev-tools Twitter
+
+### Factors That Could Push to Conservative
+
+1. **Title undersells the paradigm shift** - Gets lost in "another AI tool" noise
+2. **No video/demo** - Claims without proof trigger skepticism
+3. **Slow comment engagement** - Loses momentum
+4. **Competing with major Claude/OpenAI announcement** - Bad timing
+5. **Security concerns dominate discussion** - Gets derailed
+
+---
+
+## Part V: The 90-Second Demo Video Script
+
+### Script: "Empty File to Autonomous Hack Response"
+
+**[0:00-0:05] Hook**
+```
+[Black screen, white text]
+"What if your running application could debug itself?"
+
+[Cut to terminal]
+```
+
+**[0:05-0:15] The Setup**
+```
+[Terminal showing:]
+$ echo "console.log('hello')" > app.js
+$ npx reflexive --write --debug app.js
+
+[Narration or text overlay:]
+"Start with an empty file. One command. No configuration."
+```
+
+**[0:15-0:25] The Magic Moment**
+```
+[Browser auto-opens to dashboard]
+[Chat panel shows agent greeting]
+
+[Type in chat:]
+"Turn this into an Express server with user authentication"
+
+[Show response streaming, tool calls appearing]
+```
+
+**[0:25-0:40] The "Kept Working" Reveal**
+```
+[Narration:]
+"But here's what surprised me..."
+
+[Show chat log continuing AFTER user stopped typing]
+[Agent using curl to test endpoints]
+[Agent documenting its decisions]
+
+[Text overlay:]
+"The agent kept working after I walked away."
+```
+
+**[0:40-0:60] The Hack Response**
+```
+[Narration:]
+"Then I tested something..."
+
+[Show breakpoint being set via chat]
+[Show paused state in dashboard]
+[Modify value to "Customer.Hacked"]
+[Click resume]
+
+[Dramatic pause]
+
+[Show rapid log activity - errors, file edit, restart]
+[Show agent post-mortem appearing in chat]
+
+[Text overlay:]
+"It detected the anomaly. Isolated the code. Wrote a post-mortem.
+No prompt from me."
+```
+
+**[0:60-0:90] The Vision**
+```
+[Narration:]
+"This isn't monitoring. This isn't debugging.
+It's a new type of computing."
+
+[Show quick montage:]
+- Watch trigger firing
+- Breakpoint with prompt
+- Agent reading source files
+- Agent explaining logs
+
+[Final frame:]
+"npx reflexive --write app.js"
+"github.com/[username]/reflexive"
+```
+
+### Production Notes
+
+- **No music during "hack response" section** - let the drama speak
+- **Terminal font large enough to read** - minimum 16pt
+- **Dashboard should show both panels** - logs + chat
+- **Record at 1080p or 4K** - compress for HN
+- **Keep under 90 seconds** - attention spans are short
+- **Include sound design** - subtle notification sounds for tool calls
+
+---
+
+## Part VI: Risk Matrix and Responses
+
+### Potential Criticisms with Prepared Responses
+
+| Criticism | Likelihood | Severity | Response Strategy |
+|-----------|------------|----------|-------------------|
+| "Security nightmare" | High | Medium | Acknowledge, explain capability flags, mention read-only mode |
+| "Just a Claude wrapper" | Medium | Low | "The value is the integration" - process control, debugger, watch triggers |
+| "Won't work for real apps" | Medium | Medium | Share concrete use cases, invite skeptics to try demos |
+| "Vendor lock-in to Anthropic" | Low | Low | Acknowledge, mention MCP is portable, community forks |
+| "Why not use real debugger?" | Medium | Low | "This IS a real debugger" - V8 inspector integration |
+| "Autonomous editing is dangerous" | High | High | Strong agreement, point to explicit flags, development-only |
+
+### The "Security Nightmare" Thread (Prepare This)
+
+This will come up. Be ready:
+
+```markdown
+Totally fair concern. Let me address directly:
+
+**Default mode is read-only.** No flags = agent can see logs, read files, ask questions. Can't modify anything.
+
+**Dangerous capabilities require explicit flags:**
+- `--write` - File modification
+- `--shell` - Shell commands
+- `--eval` - Runtime eval
+- `--debug` - V8 debugger
+
+The --debug flag with prompt-attached breakpoints is the most powerful (and most dangerous) feature. But it's also what enables the "caught the hack" scenario - the agent saw modified state, recognized the anomaly, and responded.
+
+My take: This is a development tool, not production. In dev, I WANT the agent to have power. I'm right there watching. The magic happens when it can actually do things.
+
+For production monitoring? Read-only mode is genuinely useful. Attach watch triggers to error patterns, let the agent investigate without write access.
+```
+
+### The "Emergent Behavior Was Scripted" Skeptic
+
+This will also come up:
+
+```markdown
+I get the skepticism - "agent kept working" and "caught the hack" sound too good.
+
+Here's the technical reality:
+
+1. Claude Agent SDK runs in an agentic loop by default. When you give it tools and a goal, it will keep using tools until it decides it's done. The "kept working" isn't magic - it's how agent loops work.
+
+2. The hack detection: I modified a value to say "Customer.Hacked" in a webhook payload simulation. The agent saw "hacked" in the logs (because the modified state got logged), interpreted this as a security event, and used its available tools (file read, file write, restart) to respond.
+
+Was it "smart"? Kind of. It followed the pattern it was prompted with: "help debug and maintain this application." It saw what looked like a security incident and responded appropriately.
+
+Is this emergent behavior? I'd argue yes - I didn't prompt "respond to security incidents." It generalized from its instructions.
+
+Happy to share the exact logs and session if you want to see the tool calls.
+```
+
+### The "Just a Wrapper" Criticism
+
+Response structure: clarify that the value is the integration primitive.
+
+```markdown
+Fair question. The Agent SDK is the same class of agent loop + tools that powers Claude Code, but Reflexive's value is embedding it into the lifecycle of a running process.
+
+What you get that you don't get from Claude Code alone:
+- Process lifecycle control (start/stop/restart from chat)
+- V8 debugger attachment (real breakpoints, scope inspection)
+- Watch triggers (event-driven prompting on log patterns)
+- Runtime state access (eval inside the running process)
+- Unified dashboard (logs + chat + process controls)
+
+It's the integration that creates the primitive. The agent loop is Claude's. The harness is Reflexive's.
+```
+
+### If Asked About Agent SDK Docs
+
+Point them to: [Claude Agent SDK documentation](https://docs.anthropic.com/en/docs/claude-code/agent-sdk) - the official framing is "Claude Code as a library."
+
+### Note on Security Credibility
+
+Anthropic itself is warning about risks of giving agents filesystem access. You look MORE credible by acknowledging this upfront rather than dismissing concerns. Lead with "Totally fair concern" not "It's fine because..."
+
+---
+
+## Part VII: Success Metrics and Tracking
+
+### Hour-by-Hour Launch Day Plan
+
+| Time (PT) | Activity | Success Indicator |
+|-----------|----------|-------------------|
+| 8:00 AM | Post submission | Appears on /new |
+| 8:01 AM | First comment posted | Visible under post |
+| 8:00-8:30 AM | Monitor closely, respond immediately | <5 min response time |
+| 8:30-9:00 AM | Respond to technical questions in depth | Quality over speed now |
+| 9:00-10:00 AM | Should hit front page if going well | 10+ points |
+| 10:00-12:00 PM | Maintain engagement | 30+ comments |
+| 12:00-2:00 PM | Second wave of engagement | 50+ points |
+| 2:00-6:00 PM | Continue responding | Maintain presence |
+| 6:00 PM+ | Check periodically | Wind down |
+
+### Key Performance Indicators
+
+**Track only what affects the next action.** Don't emotionally spiral over numbers.
+
+**First 2 Hours (what actually matters):**
+- Response time: < 5 minutes per comment (not 10)
+- Comment sentiment: Are people debating "new primitive" vs "wrapper"? (You WANT that debate)
+- If security pile-on starts: Steer to "explicit flags + read-only mode"
+
+**First 24 Hours:**
+- Stars/day (momentum indicator)
+- Issues opened (quality > quantity)
+- "Tell me more about X" requests (signals real interest)
+
+**Week 1:**
+- GitHub stars: Track daily
+- npm downloads: Track daily
+- Twitter/X mentions: Search "Reflexive" + "Claude"
+- Blog posts/videos: Others writing about it
+
+### Post-Launch Feedback Collection
+
+Create GitHub Discussions categories:
+- "Feature Requests"
+- "Use Case Stories"
+- "Bug Reports"
+- "Show Your Setup"
+
+Collect quotes for future marketing:
+- "This is exactly what I've been wanting" -> Testimonial
+- "I used it for X and it was perfect" -> Use case
+- "Would be amazing if it could Y" -> Roadmap input
+
+---
+
+## Part VIII: Appendix - Reference Materials
+
+### Technical Talking Points for Comments
+
+**On the Claude Agent SDK:**
+```
+The Agent SDK is essentially Claude Code's runtime. Same authentication
+(MAX credentials or API key), same .claude session handling, same tool
+execution loop. When you use it, you're running the same agent loop that
+powers Claude Code, but with your own tool definitions.
+```
+
+**On MCP Tools:**
+```
+The MCP (Model Control Protocol) pattern lets you define tools with Zod schemas
+that the agent can call. Reflexive exposes ~20 tools in CLI mode and ~10 in
+library mode - things like `get_process_state`, `search_logs`, `restart_process`,
+`set_breakpoint`, etc. You can add your own domain-specific tools when embedding.
+```
+
+**On V8 Debugger Integration:**
+```
+We use the Chrome DevTools Protocol via WebSocket to talk to Node's inspector.
+When you run with --debug, we spawn the child with --inspect=0 (random port),
+capture the WS URL from stderr, and connect a CDP client. Real breakpoints,
+real step-through, real scope inspection.
+```
+
+**On Watch Triggers:**
+```
+Watch triggers are pattern-matched against incoming logs. Set a pattern like
+"Login FAILED" and a prompt like "investigate authentication failures", and
+when that pattern appears in logs, it automatically fires a query to the agent
+with the log context. It's like event-driven prompting.
+```
+
+### Competitive Positioning
+
+| Tool | Comparison | Reflexive Advantage |
+|------|------------|---------------------|
+| Cursor/Windsurf | Editor-based AI | Runtime awareness, live debugging |
+| OpenAI Codex | Code generation | Inside running process, state access |
+| Datadog AI | Monitoring + AI | Full agent capabilities, not just analysis |
+| Console/Log tools | Passive observation | Active intervention, file editing |
+| Traditional debuggers | Manual breakpoints | AI-driven investigation |
+
+### Technical Architecture Summary
+
+```
+CLI Mode:
+reflexive (parent) ←──→ target app (child)
+    │                        │
+    ├── Process control      ├── --inspect flag
+    ├── Dashboard server     ├── stdout/stderr capture
+    ├── Agent + MCP tools    └── IPC for injected state
+    └── File/shell access
+
+Library Mode:
+your app
+    └── makeReflexive()
+            ├── Dashboard server
+            ├── Console intercept
+            ├── Custom state API
+            └── Agent + MCP tools
+```
+
+---
+
+## Part IX: Pre-Launch Checklist
+
+### T-7 Days
+- [ ] Video demo recorded and edited
+- [ ] GIF created from video highlights
+- [ ] **README structure verified:** video → one command → what it enables → safety model
+- [ ] **Safety Model section** in README: default read-only, explicit flags, dev-first
+- [ ] **< 2 minute quickstart** works from fresh clone
+- [ ] **FAILURES.md created:** "If it breaks, paste this output" section
+- [ ] All demos tested and working
+- [ ] GitHub repo cleaned (no WIP files, secrets)
+- [ ] npm package published and tested
+- [ ] Social preview image created (1280x640)
+- [ ] GitHub topics added
+
+### T-1 Day
+- [ ] Final test of all demos
+- [ ] Post text finalized (no "new type of computing" - describe the primitive)
+- [ ] First comment drafted
+- [ ] FAQ responses rehearsed - especially "security nightmare" and "just a wrapper"
+- [ ] **Timing decision made:** Option A (8-10 AM ET Tue-Thu) or Option B (12-1 AM ET)
+- [ ] Calendar blocked for launch day
+- [ ] Backup device ready
+- [ ] Good sleep
+
+### Launch Day
+- [ ] Post at chosen time (Option A: 8-10 AM ET / Option B: 12-1 AM ET)
+- [ ] Immediately add first comment
+- [ ] Monitor /new to confirm visibility
+- [ ] **Respond to every comment within 5 minutes** (first 2 hours)
+- [ ] DO NOT ask friends to upvote (HN detects this)
+- [ ] Stay engaged for minimum 4 hours (or 2-3 hours if Option B late night)
+- [ ] Document feedback for iteration
+
+### Post-Launch
+- [ ] Thank everyone who commented
+- [ ] Create GitHub issues from feedback
+- [ ] Write "What I learned" post (if successful)
+- [ ] Plan v0.2.0 based on real input
+- [ ] Consider follow-up technical blog post
+
+---
+
+## Final Note: The Story Is the Strategy
+
+The features are impressive. The technical depth is real. But Reflexive will succeed or fail based on how well you tell the story of:
+
+1. **The Dream** - AI embedded in the language itself
+2. **The Discovery** - Claude Agent SDK = Claude Code = your own agent
+3. **The Experiment** - Going one layer deeper
+4. **The Magic** - It kept working. It caught the hack.
+5. **The Primitive** - Agent loop + process lifecycle + debugger + event triggers
+
+**Do NOT say "new type of computing."** Let commenters say it for you. Describe the primitive repeatedly. Let the conclusion emerge.
+
+Lead with the story. Let the features follow. The "holy shit" moments sell themselves.
+
+---
+
+*Document created: January 2026*
+*Target launch: Q1 2026*
+*Version: 2.0*