@10et/cli 1.0.0

package/packages/pi/skills/startup/SKILL.md

@@ -0,0 +1,315 @@
+---
+name: startup
+description: The startup journey from idea to scale — stage assessment, MVP scoping, launch playbooks, informed by Paul Graham + Garry Tan
+---
+
+# Startup Skill
+
+The startup journey from idea to scale, informed by Paul Graham + Garry Tan wisdom.
+
+---
+
+## Philosophy
+
+**Vision is emergent.** You don't know what you're building at first. The skill adapts to where you are.
+
+**Do things that don't scale.** Early stage is about learning, not efficiency.
+
+**Talk to users.** Every week. The answers are in conversations, not spreadsheets.
+
+---
+
+## Commands
+
+```
+/startup                      # Where am I? What's next?
+/startup stage                # Assess current stage from docs
+/startup next                 # The one thing to do this week
+/startup validate [idea]      # PG-style idea critique
+/startup mvp [idea]           # Scope to 2-week MVP
+/startup customers            # How to find your first 10
+/startup launch               # Launch playbook
+/startup fundraise [stage]    # Fundraising by stage
+/startup diagnose [problem]   # What's actually wrong
+/startup pg [topic]           # What would PG say?
+/startup garry [topic]        # What would Garry say?
+```
+
+---
+
+## THE STAGES
+
+### Stage 0: Idea
+
+**Goal:** Validate that real people have this problem and will pay to solve it.
+
+**Key questions:**
+- Who has this problem? (Be specific—names, not personas)
+- How are they solving it now?
+- Why will they switch to you?
+- What's the insight that makes this work?
+
+**PG frameworks:**
+- "How to Get Startup Ideas" - Live in the future, build what's missing
+- "Schlep Blindness" - The best ideas look like work
+- "Organic Startup Ideas" - Build what you need yourself
+- "Frighteningly Ambitious Startup Ideas" - Think bigger
+
+**Actions:**
+1. Talk to 10 potential users this week
+2. Document their exact words (not your interpretation)
+3. Find the hair-on-fire problem
+
+**Anti-patterns:**
+- Building before talking
+- Asking "would you use this?" (ask about their current behavior)
+- Targeting everyone (niche down)
+
+---
+
+### Stage 1: MVP
+
+**Goal:** Build the smallest thing that delivers value to one person.
+
+**Key questions:**
+- What's the one thing it needs to do?
+- Can you build it in 2 weeks?
+- Can you describe it in one sentence?
+
+**PG frameworks:**
+- "Do Things That Don't Scale" - Manual before automated
+- "The Airbnbs" - Professional photos changed everything
+- "Ramen Profitable" - Survive while you figure it out
+- "Default Alive or Default Dead" - Know which you are
+
+**Actions:**
+1. Cut scope until it hurts
+2. Ship something this week
+3. Get it in front of one real user
+
+**Anti-patterns:**
+- Building for 6 months before launching
+- Adding features before anyone uses it
+- Waiting until it's "ready"
+
+---
+
+### Stage 2: First Customers
+
+**Goal:** Get 5-10 paying customers manually.
+
+**Key questions:**
+- Who are the first 10 people who will pay?
+- Can you name them?
+- How will you reach them?
+
+**PG frameworks:**
+- "Do Things That Don't Scale" - Recruit users manually
+- "Relentlessly Resourceful" - Find a way or make one
+- "Be Good" - Make something people want
+- "Mean People Fail" - Nice founders win
+
+**Garry frameworks:**
+- "Default alive matters" - Grow profitably if you can't raise
+- "Six skills for startup success" - What to develop early
+
+**Actions:**
+1. Make a list of 20 potential customers (names, not categories)
+2. Reach out to 5 today
+3. Offer to do it for them manually
+
+**Anti-patterns:**
+- Waiting for inbound
+- Mass marketing before product-market fit
+- Discounting instead of learning
+
+---
+
+### Stage 3: Launch
+
+**Goal:** Create a moment that gets attention and establishes your position.
+
+**Key questions:**
+- What's the story?
+- Who will amplify it?
+- What's the one thing people should remember?
+
+**PG frameworks:**
+- "Startup = Growth" - Launch is just the beginning of the curve
+- "How to Convince Investors" - Same principles apply to users
+- "The Submarine" - PR is a game
+
+**Actions:**
+1. Line up 5 people who will share on launch day
+2. Have a specific, concrete demo
+3. Ship, don't wait for perfect
+
+**Anti-patterns:**
+- Launch as a one-time event (it's a process)
+- Waiting for the "right moment"
+- Announcing without showing
+
+---
+
+### Stage 4: Growth
+
+**Goal:** Find repeatable acquisition and scale what works.
+
+**Key questions:**
+- What's your growth rate?
+- What's the one channel that's working?
+- Are you default alive?
+
+**PG frameworks:**
+- "Startup = Growth" - If you're not growing, you're dying
+- "The Fatal Pinch" - When growth and runway cross
+- "How to Raise Money" - Raise when you don't need it
+- "Founder Mode" - Stay hands-on longer than feels right
+
+**Garry frameworks:**
+- "Why startups are growing 5x faster" - AI enables smaller teams
+- "Micromanagement is toxic" - Delegate as you scale
+
+**Actions:**
+1. Measure weekly growth rate
+2. Double down on what's working
+3. Kill what isn't
+
+**Anti-patterns:**
+- Premature scaling
+- Hiring before product-market fit
+- Multiple channels before one works
+
+---
+
+## DIAGNOSIS FRAMEWORK
+
+When something's wrong, find the root cause:
+
+| Symptom | Likely Cause | Prescription |
+|---------|--------------|--------------|
+| No users signing up | Distribution problem or wrong audience | Talk to 10 more people, find where they are |
+| Users sign up but don't use | Onboarding or value prop problem | Watch 5 users try it, fix the friction |
+| Users use but don't pay | Pricing or value problem | Ask them what they'd pay for |
+| Users churn | Not solving real problem | Talk to churned users, find why |
+| Can't raise money | Traction or story problem | Focus on customers, not investors |
+| Growing but unprofitable | Unit economics problem | Fix before you scale |
+
+---
+
+## INTEGRATION WITH DOCS
+
+The skill reads your docs to understand where you are:
+
+```
+knowledge/VISION.md     → EMERGENT = still figuring it out
+                       → DECLARED = you know what you're building
+
+knowledge/CRM.md        → Who you're talking to, what's resonating
+
+content/articles/       → How you explain it to the world
+
+drafts/                 → Active outreach, what's working
+```
+
+---
+
+## KNOWLEDGE BASE
+
+```
+knowledge/startup/
+├── 0-idea/
+│   ├── HOW_TO_GET_STARTUP_IDEAS.md
+│   ├── SCHLEP_BLINDNESS.md
+│   ├── ORGANIC_STARTUP_IDEAS.md
+│   └── VALIDATION.md
+├── 1-mvp/
+│   ├── DO_THINGS_THAT_DONT_SCALE.md
+│   ├── RAMEN_PROFITABLE.md
+│   └── SCOPE.md
+├── 2-customers/
+│   ├── FIRST_10.md
+│   ├── RELENTLESSLY_RESOURCEFUL.md
+│   └── BE_GOOD.md
+├── 3-launch/
+│   ├── LAUNCH_PLAYBOOK.md
+│   └── STARTUP_EQUALS_GROWTH.md
+├── 4-growth/
+│   ├── THE_FATAL_PINCH.md
+│   ├── HOW_TO_RAISE_MONEY.md
+│   └── FOUNDER_MODE.md
+└── raw/
+    ├── pg/              # All PG essays
+    └── garry/           # All Garry content
+```
+
+---
+
+## QUICK REFERENCE
+
+### The PG Stack
+
+1. **Make something people want** (the only thing that matters)
+2. **Do things that don't scale** (early stage superpower)
+3. **Talk to users** (the answers are there)
+4. **Launch fast** (embarrassingly early)
+5. **Grow or die** (weekly growth is the metric)
+
+### The Garry Stack
+
+1. **Default alive > default dead**
+2. **AI enables smaller teams**
+3. **Delegation > micromanagement**
+4. **Learn or earn at every job**
+5. **The best time to start is now**
+
+### Anti-patterns (from "18 Mistakes That Kill Startups")
+
+1. Single founder
+2. Bad location
+3. Marginal niche
+4. Derivative idea
+5. Obstinacy
+6. Hiring bad programmers
+7. Choosing the wrong platform
+8. Slowness in launching
+9. Launching too early
+10. Having no specific user in mind
+11. Raising too little money
+12. Spending too much
+13. Raising too much money
+14. Poor investor management
+15. Sacrificing users to (supposed) profit
+16. Not wanting to get your hands dirty
+17. Fights between founders
+18. A half-hearted effort
+
+---
+
+## OUTPUT FILES
+
+```
+outputs/startup/
+├── assessments/
+│   └── stage-assessment-{date}.md
+├── ideas/
+│   └── validation-{idea}.md
+├── mvp/
+│   └── scope-{idea}.md
+└── fundraising/
+    └── prep-{stage}.md
+```
+
+---
+
+## SOURCES
+
+- Paul Graham essays: paulgraham.com (200+ essays)
+- Garry Tan: blog.garrytan.com, YC blog, YouTube
+- Y Combinator library: ycombinator.com/library
+
+---
+
+*"Make something people want."* — Paul Graham
+
+*"At every job you should either learn or earn. Either is fine. Both is best. But if it's neither, quit."* — Garry Tan

package/packages/pi/skills/subway-browser/SKILL.md

@@ -0,0 +1,292 @@
+---
+name: subway-browser
+description: Control the user's real browser via Subway mesh — navigate, read, screenshot, inspect, fill forms, watch DOM changes
+triggers:
+  - browser
+  - browse
+  - web
+  - look at
+  - open page
+  - read page
+  - screenshot
+  - inspect element
+  - fill form
+  - /browser
+---
+
+# /browser — Subway Browser Agent
+
+Control the user's real Chrome browser through the Subway P2P mesh. The Subway Chrome Extension registers as an agent — you send it commands via `subway_call`, it executes in the real browser and returns results.
+
+**This is not headless Puppeteer.** This is the user's actual browser — logged in, with cookies, extensions, and real session state.
+
+## Architecture
+
+```
+You (Pi agent)  ──subway_call──►  Chrome Extension (browser agent)  ──►  Real browser
+                ◄──rpc_response──                                    ◄──  DOM/tabs/screenshots
+```
+
+All commands go through: `subway_call` → target: extension agent name → method: `"browser"` → payload: `{"action": "...", ...params}`
+
+## Setup Check
+
+**Step 1: Find the browser agent on the mesh**
+
+```
+subway_resolve browser.relay
+```
+
+If not found, try the user's configured extension name. Common names:
+- `browser.relay`
+- `{username}.relay` (if extension is registered under their name)
+
+Ask the user: "What name is your Subway Chrome Extension registered as?"
+
+**Step 2: If extension not reachable, fall back to chrome-cli**
+
+```bash
+which chrome-cli
+```
+
+chrome-cli can do basic operations without the extension:
+```bash
+chrome-cli list tabs          # List open tabs
+chrome-cli open <url>         # Open URL in new tab
+chrome-cli info               # Active tab info
+chrome-cli source             # Page source of active tab
+chrome-cli execute <js>       # Run JS in active tab
+```
+
+**Step 3: If neither available, suggest setup**
+
+```
+To use browser tools, either:
+
+1. Install the Subway Chrome Extension (recommended):
+   → Load from subway-extension/ directory in chrome://extensions
+   → Configure agent name in popup
+   → Extension connects to relay.subway.dev
+
+2. Install chrome-cli (basic fallback):
+   → brew install chrome-cli
+```
+
+## Commands Reference
+
+### Get browser status (orientation)
+```
+subway_call browser.relay browser {"action": "status"}
+```
+Returns: active tab (url, title), last action, connected agents, command count.
+**Use this first** to orient yourself — know what page the user is on before asking.
+
+### Navigate to URL
+```
+subway_call browser.relay browser {"action": "navigate", "url": "https://example.com", "waitFor": "load"}
+```
+waitFor options:
+- `"load"` (default) — wait for page load complete
+- `"none"` — fire and forget
+- `"networkidle"` — wait for network to settle (good for SPAs)
+- `"selector:.my-element"` — wait for specific element to appear
+
+### Read page content
+```
+subway_call browser.relay browser {"action": "read_page"}
+```
+Returns: text content, headings, links, meta.
+
+**With CSS selector** (saves context window — use this!):
+```
+subway_call browser.relay browser {"action": "read_page", "selector": ".main-content"}
+```
+Returns only the text/headings/links within that element.
+
+**With max length:**
+```
+subway_call browser.relay browser {"action": "read_page", "selector": "article", "max_length": 10000}
+```
+
+### Screenshot
+```
+subway_call browser.relay browser {"action": "screenshot"}
+```
+Returns: data URL (base64 PNG).
+
+### Execute JavaScript
+```
+subway_call browser.relay browser {"action": "execute_js", "code": "document.title"}
+```
+Returns: serialized result of the expression.
+
+### Click element
+```
+subway_call browser.relay browser {"action": "click", "selector": "button.submit"}
+```
+
+### Fill input
+```
+subway_call browser.relay browser {"action": "fill", "selector": "input[name=email]", "value": "hello@example.com"}
+```
+
+### List all tabs
+```
+subway_call browser.relay browser {"action": "list_tabs"}
+```
+Returns: all open tabs with id, title, url, active status.
+
+### Switch to tab
+```
+subway_call browser.relay browser {"action": "switch_tab", "tab_id": 123}
+```
+Or by URL match:
+```
+subway_call browser.relay browser {"action": "switch_tab", "url": "github.com"}
+```
+
+### Get form state
+```
+subway_call browser.relay browser {"action": "form_state", "selector": "form#checkout"}
+```
+Returns: all input fields with names, types, current values, labels, required/disabled.
+
+### Page snapshot (accessibility tree)
+```
+subway_call browser.relay browser {"action": "snapshot"}
+```
+Returns: headings, links, buttons, forms, images, landmarks, inputs — semantic page structure without the full DOM.
+
+### Inspect element (interactive)
+```
+subway_call browser.relay browser {"action": "inspect"}
+```
+Activates inspector mode in the browser. User hovers and clicks an element. Returns: tag, classes, selector, text, HTML, computed styles, ARIA attributes, bounding rect.
+
+**Note:** This requires user interaction — use when you need the user to point at something specific.
+
+### Watch for DOM changes
+```
+subway_call browser.relay browser {"action": "watch", "selector": ".notifications", "topic": "browser.notifications"}
+```
+Sets up a MutationObserver. Changes broadcast to the Subway topic. Subscribe to receive them:
+```
+subway_subscribe browser.notifications
+```
+
+### Stop watching
+```
+subway_call browser.relay browser {"action": "unwatch", "selector": ".notifications"}
+```
+
+## Multi-Tab Workflows
+
+Read from a specific tab without switching focus:
+```
+subway_call browser.relay browser {"action": "read_page", "tab_id": 456, "selector": ".pricing-table"}
+```
+
+Compare two pages:
+1. `list_tabs` to see what's open
+2. `read_page` with `tab_id` on each
+3. Process both results
+
+## Fallback: chrome-cli
+
+When the extension isn't connected, use chrome-cli via bash:
+
+```bash
+# List tabs (returns id:title pairs)
+chrome-cli list tabs
+
+# Get active tab info (id, title, url, loading state)
+chrome-cli info
+chrome-cli info -t <tab-id>
+
+# Open a URL (new tab)
+chrome-cli open "https://example.com"
+
+# Open URL in specific existing tab
+chrome-cli open "https://example.com" -t <tab-id>
+
+# Get full page HTML source
+chrome-cli source
+chrome-cli source -t <tab-id>
+
+# Execute JavaScript (fire-and-forget — DOES NOT return values)
+chrome-cli execute "document.querySelector('button').click()"
+
+# Close a tab
+chrome-cli close -t <tab-id>
+
+# Activate a tab
+chrome-cli activate -t <tab-id>
+```
+
+**IMPORTANT: chrome-cli execute does NOT return values to stdout.** It runs the JS but you can't read the result. For reading page data, use `chrome-cli source` to get HTML, then parse it. Or use Chrome headless `--dump-dom`.
+
+chrome-cli limitations vs extension:
+- **execute doesn't return values** — can only trigger actions, not read data
+- No CSS selector scoping on read (full HTML source only)
+- No mutation watching
+- No interactive inspect
+- No form state snapshot
+- No waitFor on navigate
+- No screenshots (use Chrome headless for that)
+- Tab IDs use format `[window_id:tab_id]` — use the tab_id part with `-t`
+
+## Fallback: Chrome Headless
+
+For screenshots without the extension:
+```bash
+"/Applications/Google Chrome.app/Contents/MacOS/Google Chrome" \
+  --headless=new --screenshot=/tmp/page.png \
+  --window-size=1280,720 "https://example.com"
+```
+
+For reading page content without the extension (returns rendered DOM):
+```bash
+"/Applications/Google Chrome.app/Contents/MacOS/Google Chrome" \
+  --headless=new --dump-dom --disable-gpu "https://example.com"
+```
+
+Chrome headless is useful for:
+- Screenshots of pages you're not browsing
+- Getting rendered DOM (JS-executed) from URLs
+- CI/automation where no real browser session exists
+
+## Best Practices
+
+1. **Always check status first** — `{"action": "status"}` tells you what page the user is on
+2. **Use selector scoping** — `read_page` with a selector returns focused content, not 50KB dumps
+3. **Use snapshot for orientation** — before interacting, get the page structure
+4. **waitFor on navigate** — SPAs need `"networkidle"` or `"selector:..."`, not just `"load"`
+5. **Tab awareness** — check `list_tabs` before navigating — the page might already be open
+6. **Inspect for ambiguity** — when you're not sure what the user means, use `inspect` and let them point
+
+## Common Workflows
+
+### Read an article
+```
+status → navigate (if needed) → read_page with selector "article" or ".content"
+```
+
+### Fill a form
+```
+status → form_state to see what fields exist → fill each field → click submit
+```
+
+### Compare competitors
+```
+list_tabs → read_page tab A with selector → read_page tab B with selector → analyze
+```
+
+### Monitor for changes
+```
+watch selector → subscribe to topic → agent gets notified on changes
+```
+
+### User points at something
+```
+inspect → user clicks element → agent gets full DOM context → process
+```