release: bump versionCode 5->6 for v0.4.4 + add changelog 6.txt

v0.4.3 already shipped as versionCode 5; a duplicate code would be rejected by Play and ignored by F-Droid. Bump to 6 unblocks the v0.4.4 release. QA gate passed (units + on-device E2E + visual render check screenshots in docs/qa/render-check/).

docs/marketing/ASSETS.md

@@ -0,0 +1,62 @@
+# Visual & Demo Assets — what exists, what's needed
+
+Conversion-ranked. A short **demo video** and a **diff screenshot** are the two highest-leverage missing pieces.
+
+---
+
+## What already exists (in repo)
+
+| Asset | Path | Size | Status |
+|---|---|---|---|
+| App icon | `distribution/play-graphics/icon-512.png` and `fastlane/metadata/android/en-US/images/icon.png` | 512×512 | Ready (Play, PH, GitHub social, favicon source) |
+| Feature graphic | `distribution/play-graphics/feature-graphic.png` and `fastlane/.../images/featureGraphic.png` | 1024×500 | Ready (Play feature graphic). NOT the right ratio for a PH thumbnail (PH wants ~1270×760) or X card — make a variant. |
+| Screenshot 1 — Connect screen | `fastlane/metadata/android/en-US/images/phoneScreenshots/01.png` (also in `docs-site/screenshots/01.png`) | 1080×2400 | Usable, BUT has a visible rendering glitch (see "Fix" below). Shows: server URL field, nickname, Connect button, a saved "Home MacBook · Connected" entry, and Cloudflare Tunnel / ngrok tunnel buttons. Good story. |
+| Screenshot 2 — Live streaming + approval | `.../phoneScreenshots/02.png` (also `docs-site/screenshots/02.png`) | 1080×2400 | Strong. Shows a real prompt ("Refactor the auth middleware…"), `opencode streaming…`, reading a file, a `+` diff, and **Approve / Reject** buttons. This is the money shot — use it first on PH and the landing hero. |
+| Screenshot 3 — Full diff view | `.../phoneScreenshots/03.png` (also `docs-site/screenshots/03.png`) | 1080×2400 | Content is right (full `+/-` diff of `auth.ts` with **Accept All / Discard**) but it is **rendered/scaled small with letterboxing** — looks low quality at full size. Needs re-capture at native 1080×2400. |
+| Old low-res screenshot | `distribution/play-graphics/screenshots/01-no-connection.png` | 320×640 | Obsolete — do not use (too small, below Play's 320px-min comfort and looks dated). |
+
+The three 1080×2400 screenshots are already wired into both the Play fastlane listing and the docs-site. The Play store listing graphics are covered.
+
+---
+
+## Fixes needed on existing assets
+
+1. **Screenshot 01 glitch:** the blue "Connect with URL" header button overlaps its own text label (the label sits on top of a full-width blue bar). Re-capture so the segmented control / header renders cleanly before using it in any marketing context.
+2. **Screenshot 03 quality:** re-capture at native 1080×2400 (current file is the diff view but scaled down with black letterbox bars). The diff is the single best differentiator — it must look crisp.
+3. **Caption overlays:** the raw screenshots have no captions. For Play/PH, produce captioned variants (text overlay on the dark bg) per the shot list in `product-hunt.md`. Plain screenshots convert worse than captioned ones on store/PH galleries.
+
+---
+
+## What's still needed (priority order)
+
+### P0 — biggest conversion lift
+1. **Demo video, 60–90s** (screen recording of a real session): launch → paste server URL / pick tunnel → send a prompt → watch token streaming → see the inline diff → tap **Approve** → done. This is the #1 asset for PH, the landing page hero, dev.to embed, and Reddit. Nothing sells "control your agent from your phone" like motion.
+   - Also cut a **15–20s vertical clip** (1080×1920) for X / YouTube Shorts.
+   - Export a **looping GIF (≤5MB, ~10–15s)** of the stream→diff→approve moment for embeds where video is awkward (Reddit, GitHub README).
+
+### P1 — needed for Product Hunt / landing polish
+2. **6 captioned gallery screenshots** per the `product-hunt.md` shot list (1080×1920 portrait, dark theme, real UI):
+   1. Connection setup (use the fixed v of screenshot 01)
+   2. Active streaming session (screenshot 02 — already good)
+   3. Diff viewer (use a re-captured, crisp screenshot 03)
+   4. Tool-call approval bottom sheet (screenshot 02 covers part of this; a dedicated shot is better)
+   5. Session list (NEW — not currently captured; need a screen showing multiple named sessions + timestamps)
+   6. Biometric unlock prompt (NEW, optional — reinforces the privacy story)
+3. **PH thumbnail / hero graphic** ~1270×760, dark bg (#0F172A), icon left, device showing the streaming/diff screen right, headline "AI Coding Agent. In Your Pocket." (The 1024×500 feature graphic is the wrong ratio for this.)
+
+### P2 — nice to have / SEO & social
+4. **OG / social-share image** (1200×630) for the landing page and link unfurls on X/Reddit/Slack/Discord. (Project memory says an OG image exists for SEO — verify it's current and shows the app, not just text.)
+5. **Animated terminal-to-phone diagram** or a simple architecture graphic for dev.to / README: `your server (opencode + your keys) ⇄ tunnel ⇄ phone (thin client)`. Reinforces the "no backend of mine" trust message that's central to every post.
+6. **A "session list" screen** is the one feature in the messaging (manage multiple sessions) that currently has NO screenshot — worth capturing for completeness.
+
+---
+
+## Quick checklist before T0
+- [ ] Re-capture screenshot 01 (no overlap glitch)
+- [ ] Re-capture screenshot 03 at native 1080×2400
+- [ ] Capture session-list screen
+- [ ] Produce 6 captioned PH gallery shots
+- [ ] Record 60–90s demo video + 15s vertical clip + GIF
+- [ ] Make 1270×760 PH/hero thumbnail
+- [ ] Verify OG image (1200×630) is current and shows the app
+- [ ] Confirm `cover_image` URL in `devto.md` resolves to a hosted hero image

docs/marketing/CAMPAIGN.md

@@ -0,0 +1,209 @@
+# OpenCode Mobile — Launch Campaign Plan
+
+> Owner: dzianisv (dzianisvv@gmail.com). All copy in this folder is verified-true. Do not invent metrics, ratings, or store claims.
+> `{{PLAY_URL}}` = `https://play.google.com/store/apps/details?id=cc.agentlabs.opencode` — Play submitted to production review 2026-06-02, IN REVIEW, auto-publishes on approval (typically ≤7 days). Treat as "launching imminently"; swap the placeholder the moment it goes live.
+
+---
+
+## 1. Positioning & core narrative
+
+**One-liner:** Drive your self-hosted AI coding agent from your phone.
+
+**Category:** Mobile companion / remote control for the [opencode](https://github.com/sst/opencode) AI coding agent. NOT a chatbot, NOT an IDE, NOT a hosted AI service.
+
+**Core narrative (the story every post tells):**
+> AI coding agents now run long, autonomous sessions. opencode is one of the best open-source ones — but it lives on your laptop/server, and the moment you walk away you lose all control. OpenCode Mobile gives you a real native client to *steer* those sessions from your phone: watch the agent code in real time, see every diff, and approve or block every file write and shell command — without your code, keys, or traffic ever leaving your own infrastructure.
+
+**Three pillars (lead with the one that fits the audience):**
+1. **Control, not just chat** — streaming + inline diffs + tool-call approval. The differentiator vs. SSH/terminal apps and generic AI chat apps.
+2. **Self-hosted & private by default** — your server, your keys, no proprietary backend, no accounts, telemetry off by default, MIT. (Lead pillar for r/selfhosted, HN, privacy crowd.)
+3. **Bring your own model** — Claude / GPT / Gemini / local LLMs via any OpenAI-compatible endpoint. (Lead pillar for r/LocalLLaMA.)
+
+**What makes it credible (proof points, all true):**
+- Open source, MIT, public repo + CI building signed AAB on every tag.
+- Real engineering substance (SSE polyfill fix, WebView-free diff renderer, async approval coordination).
+- Zero lock-in: no account, no required subscription, no analytics by default.
+- Multiple legitimate install channels already live (F-Droid self-hosted repo + direct APK + landing/guide), Play imminent.
+
+**Honest friction to address head-on (don't hide it):** You need your own opencode server. See risk list (§9) for messaging.
+
+---
+
+## 2. Target audiences & where they hang out
+
+| Audience | Why they care | Where to reach them |
+|---|---|---|
+| Existing opencode users | Direct upgrade to their workflow; lowest-friction converts | sst/opencode GitHub Discussions, opencode Discord, X mentions of "opencode" |
+| Self-hosters / homelabbers | "Your server, your keys" resonates hard | r/selfhosted, r/homelab, r/HomeServer, lemmy selfhosted, awesome-selfhosted |
+| Local-LLM enthusiasts | Bring-your-own-model + privacy | r/LocalLLaMA, r/ollama, LocalLLaMA Discord, ollama community |
+| Android engineers | RN/Expo implementation story | r/androiddev, Android Weekly, Kotlin/Android Slacks, X #AndroidDev |
+| AI-coding / dev-tools crowd | New tool in a hot category | HN, r/programming (carefully), dev.to, Product Hunt, X dev community |
+| Tailscale / Cloudflare Tunnel users | The connectivity story is native to them | Tailscale community forum/Discord, r/Tailscale, Cloudflare community |
+| F-Droid / FOSS Android users | MIT + F-Droid repo + privacy | r/fdroid, r/fossdroid, IzzyOnDroid ecosystem |
+
+---
+
+## 3. Day-by-day launch sequence (T-7 → T+30)
+
+### Pre-launch (T-7 → T-1)
+- **T-7:** Lock all assets. Capture/finish the 6 PH/landing screenshots + a 20–40s demo GIF/video (see ASSETS.md). Verify landing, guide, F-Droid repo, and latest APK release are all reachable. Polish the GitHub README so the repo (the link everything points to) converts.
+- **T-6:** Pre-seed the niche communities that are NOT launch-day broadcasts: open a friendly post/comment in **sst/opencode Discussions** ("built a mobile client for opencode, feedback welcome") and the **opencode Discord**. These warm users are your earliest upvoters and most credible commenters.
+- **T-5:** Submit listings that take time to appear: **AlternativeTo**, **LibHunt/Awesome lists** PRs (awesome-selfhosted, awesome-android, awesome-ai-coding/awesome-opencode if one exists), **F-Droid IzzyOnDroid** consideration. These are evergreen and don't compete with launch day.
+- **T-3:** Draft and schedule the X thread; line up the Product Hunt page as a draft (don't publish). Decide exact HN day (Tue–Thu).
+- **T-1:** Final reachability check of every URL in every post. Confirm whether Play has approved — if yes, replace `{{PLAY_URL}}` everywhere; if not, keep "in review, going live shortly." Pre-write answers to the top 10 anticipated questions (§7).
+
+### Launch day (T0 — pick a Tuesday, Wednesday, or Thursday)
+Tight single-day sequence; do NOT blast every channel at once — stagger to build momentum and look organic.
+
+| Time (US Eastern) | Action | File |
+|---|---|---|
+| 08:30–09:30 | **Show HN** (the anchor) | `show-hn.md` |
+| ~10:30 (≈1h after HN) | **r/selfhosted** | `reddit-selfhosted.md` |
+| ~12:00 | **X thread**; reply to last tweet with the HN link | `x-thread.md` |
+| ~13:00 (≈2h after HN, if HN is doing well) | **r/androiddev** | `reddit-androiddev.md` |
+| Afternoon | Post a heads-up in opencode Discord + sst/opencode Discussions linking the HN thread | — |
+| All day | **Babysit HN.** Reply to every comment within ~1h. This is the single highest-leverage activity. | — |
+
+### T+1 → T+2
+- **T+1:** **r/LocalLLaMA** (different day from r/selfhosted to avoid cross-post spam perception). Reply to all Reddit comments within a few hours.
+- **T+2:** **Publish dev.to article** (evergreen SEO; canonical → landing page). Cross-link from the X thread.
+
+### T+3 (or next clean midnight PT)
+- **Product Hunt** launch at 12:01am PT. Maker comment within 60s. Rally any friendly network early (PH weighs early velocity). Reply to every PH comment.
+
+### T+4 → T+7
+- File/finish **awesome-list PRs** that weren't done in pre-launch.
+- Post to secondary subreddits one per day, spaced out: r/homelab, r/ollama, r/fdroid, r/Tailscale (tailor each to its angle; never copy-paste identical bodies).
+- Watch for the Play approval; when it lands, **edit every live post** that allows editing to swap in `{{PLAY_URL}}`, and post a short "now on Google Play" follow-up tweet.
+
+### T+7 → T+30 (sustain)
+- **Content cadence:** 1 short technical post/week (dev.to / blog) — e.g. "How opencode's tool-call approval works", "Reaching your homelab from your phone: Tailscale vs Cloudflare Tunnel", "Running opencode with a local model". Each links back to the app naturally.
+- **Demo video** to YouTube (T+10ish) — 60–90s screen capture of a real session: connect → prompt → stream → diff → approve. Embed on landing page and in dev.to.
+- **Engage upstream:** keep replying in opencode community; offer to be listed in opencode's docs/ecosystem if they have one.
+- **Iterate from feedback:** ship 1–2 visible improvements driven by launch feedback and post the changelog (gives a reason for a second wave of posts).
+- **Re-post cadence:** a tool can be reposted to a subreddit roughly once a quarter with a genuine update — schedule the next wave around the Play "now live" milestone if it lands after launch week.
+
+---
+
+## 4. Channel sequencing rules (avoid penalties)
+
+- **HN first, always.** It's the highest-signal audience and gives social proof you can reference elsewhere ("also on HN today"). One submission only — never re-submit.
+- **Never post identical text to multiple subreddits the same day.** Reddit's spam filters and mods flag cross-posting. Each subreddit gets its own tailored title + body (already written per-sub) and its own day where possible.
+- **Don't link-drop your own site in tweet 1** — X throttles link-first posts. Links go in the last tweet / first reply.
+- **r/programming and r/programming-adjacent:** only if HN does well and you can frame it as the technical write-up, not a launch ad. High removal risk otherwise; optional.
+- **Product Hunt last among the "big" channels** — it benefits from the existing buzz and gives a clean second spike.
+- **Discord/forum communities:** participate, don't spam. One genuine post + answer questions. Read each server's self-promo rules first (many have a dedicated #show-and-tell / #projects channel).
+
+**Optimal post times (general):**
+- HN: Tue–Thu 08:00–10:00 ET.
+- Reddit (US/EU subs): weekday mornings 8–11am ET.
+- X: 9–11am or 1–3pm ET weekdays.
+- Product Hunt: 12:01am PT.
+- dev.to: any weekday morning; it's evergreen.
+
+---
+
+## 5. Additional growth channels (beyond the drafts)
+
+**Directories & lists (evergreen, do once):**
+- **AlternativeTo** — list as an alternative to terminal AI tools / mobile dev clients.
+- **awesome-selfhosted**, **awesome-android**, **awesome-react-native**, any **awesome-ai-coding / awesome-opencode** list — open PRs.
+- **LibHunt** — submit the GitHub repo.
+- **F-Droid / IzzyOnDroid** — beyond the self-hosted repo, pursue mainline/IzzyOnDroid inclusion (MR #39530 pending per project memory; chase it). Wider reach than the self-hosted repo alone.
+- **OpenSourceAlternative.to**, **Slant**, **SaaSHub** — quick listings.
+
+**Communities to be present in (not spam):**
+- **sst/opencode** GitHub Discussions + Discord — your warmest, most relevant audience. Highest-conversion channel by far.
+- **Tailscale** community forum / Discord — the "reach your homelab from your phone" story is perfect there.
+- **Cloudflare** community + **ngrok** community — same connectivity angle.
+- **Expo / React Native** Discord #showcase — the build story.
+- **r/ollama**, ollama Discord — local-model angle.
+
+**Content / SEO cadence (T+7 onward, 1/week):**
+- "How to reach your self-hosted opencode server from your phone (Tailscale / Cloudflare Tunnel / ngrok)" — captures setup search intent.
+- "Running opencode with a local LLM and a mobile UI."
+- "Tool-call approval: why human-in-the-loop matters for autonomous coding agents."
+- Each canonical-points to the landing page; each embeds the demo video.
+
+**YouTube / demo:**
+- 60–90s screen-recorded real session (connect → prompt → stream → diff → approve → done). This is the single most conversion-lifting asset for PH, landing, dev.to, and Reddit. Also cut a 15s vertical clip for X/Shorts.
+
+**SEO basics (mostly done — verify):** sitemap, robots, OG image, IndexNow already live per project memory. Make sure the landing page has the demo video and clear "you need your own server" framing above the fold.
+
+---
+
+## 6. Metrics & realistic targets
+
+**Track (weekly):**
+- GitHub: stars, unique clones, release (APK) download counts, issues/PRs opened.
+- F-Droid repo: index.json fetches / APK downloads (server logs).
+- Play Console (once live): installs, store-listing views, conversion %, crash-free rate, ratings.
+- Referral traffic to landing page (GitHub Pages analytics / Plausible if added) by source.
+- Per-channel: HN points + rank + comments; Reddit upvotes/comments per sub; PH rank + upvotes; X impressions/engagement; dev.to reads/reactions.
+
+**Realistic targets (a niche dev tool with a self-hosting prerequisite — be honest, this is not a consumer app):**
+- **Launch week:** HN front page (top 30) for a few hours = several thousand repo visits; 150–400 GitHub stars; 200–800 APK + F-Droid downloads combined; PH top 10 in Dev Tools for the day.
+- **Month 1:** 400–1,000 stars; 1,000–3,000 total installs across F-Droid + APK + Play; a handful of community issues/PRs (a good health signal).
+- **Leading indicator that matters most:** retained, returning users (people who connect a server and come back) and inbound issues — both signal real adoption beyond a launch-day spike.
+
+Note: download numbers hinge heavily on Play going live (massively lowers install friction) and on the demo video existing. Both are the biggest levers.
+
+---
+
+## 7. Engagement / response playbook
+
+**Golden rule:** Be the builder, be fast, be honest. On HN especially, the first hour of replies sets the tone and drives the ranking.
+
+**Cadence:** HN — reply within ~1h all day. Reddit — within a few hours. PH — within the hour. X — same day.
+
+**Tone:** technical, humble, no marketing-speak. Concede limitations openly; it builds trust and disarms critics.
+
+**Prep these FAQ answers (paste-ready):**
+
+- **"Do I need my own server? That's a lot of friction."**
+  Yes — it's a client for opencode, which you self-host. That's deliberate: your code and API keys never leave your infrastructure, there's no backend of mine to trust, and you can point it at any model including local ones. Setup is two commands. If you already run opencode, it's instant.
+
+- **"Why not just SSH + a terminal app / tmux?"**
+  You can, but you lose the structured session UI: no inline diffs, no tool-call approval gate, no clean session switching. The whole point is *steering* the agent (approve/reject actions), not reading raw text.
+
+- **"Is my code / are my keys sent to you?"**
+  No. The app talks directly to your server. No proprietary backend, no accounts. Sentry crash reporting is opt-in and off by default; connection secrets live in the Android Keystore.
+
+- **"iOS?"**
+  Android only right now. (State it plainly; don't promise iOS unless it's real.)
+
+- **"How does it handle a slow/local model?"**
+  Streams token-by-token via SSE with a minimum render interval to avoid UI thrash. Genuinely want feedback on how it feels at low tok/s.
+
+- **"Is it on Google Play / F-Droid main catalog?"**
+  Available now via a self-hosted F-Droid repo and direct signed APK. Google Play is in review and going live shortly. Mainline F-Droid/IzzyOnDroid inclusion is in progress.
+
+- **"What models does it support?"**
+  Whatever opencode supports — Claude, GPT, Gemini, or any OpenAI-compatible/local endpoint. The app is model-agnostic; opencode handles the provider.
+
+- **"Security of exposing my server?"**
+  Use Tailscale (no public exposure) for the safest setup; Cloudflare Tunnel/ngrok give HTTPS if you need public reach. opencode supports a server password. The guide covers this.
+
+**Handling negativity:** Thank, clarify, don't get defensive. If someone finds a real bug, file an issue on the spot and link it — public responsiveness is great marketing.
+
+---
+
+## 8. Cross-references
+- Channel posts: `show-hn.md`, `reddit-selfhosted.md`, `reddit-localllama.md`, `reddit-androiddev.md`, `product-hunt.md`, `x-thread.md`, `devto.md`
+- Assets status & gaps: `ASSETS.md`
+
+---
+
+## 9. Risk list & mitigations
+
+| Risk | Impact | Mitigation |
+|---|---|---|
+| **"I need my own server" friction** turns away casual installers | Lower install→active conversion | Reframe as the feature (privacy, no lock-in, BYO model). Make the guide dead-simple (two commands). Target audiences who already self-host. Don't market to people who want a turnkey chatbot. |
+| HN/Reddit reads it as spam or low-effort | Removal, downvotes | Lead with engineering substance, tailor every post per platform, never copy-paste across subs, be present to answer. |
+| Play approval slips past launch week | Higher install friction during peak attention | Drafts already say "going live shortly" with swappable `{{PLAY_URL}}`; F-Droid repo + APK carry installs in the meantime; do a "now on Play" follow-up wave when it lands. |
+| No demo video at launch | Big conversion loss (this is the #1 gap) | Prioritize the 60–90s demo before T0 (see ASSETS.md). At minimum ship the GIF. |
+| Confusion: people think the app *is* the AI / runs models | Wrong expectations, bad reviews | Every post states plainly "you need a running opencode server; the app is a thin client." Keep saying it. |
+| Security FUD about exposing a home server | Hesitation | Push Tailscale as the default safe path; mention server password; link the guide. |
+| Cross-posting penalties | Shadow-removal, mod bans | Stagger days, unique copy per channel (done). |
+| Over-promising (iOS, ratings, "#1") | Trust damage / store policy | Never claim what isn't true. No fake metrics, no other-store claims. iOS = "Android only" plainly. |
+| Single-maintainer support load after a spike | Burnout, slow replies hurt rep | Pre-write FAQ answers (§7), triage issues, accept it's a marathon — sustain cadence in §3. |

docs/marketing/devto.md

@@ -0,0 +1,71 @@
+---
+title: "Drive your self-hosted AI coding agent from your phone"
+published: true
+tags: [android, selfhosted, ai, devtools]
+cover_image: https://dzianisv.github.io/opencode-mobile/play-graphics/feature-graphic.png
+canonical_url: https://dzianisv.github.io/opencode-mobile/
+---
+
+> Publish on dev.to a day or two AFTER the HN/Reddit launch — it's evergreen SEO, not a same-day play. Set `canonical_url` to the landing page so the landing page gets SEO credit. Swap `cover_image` for a hosted hero/feature graphic before publishing. Replace `{{PLAY_URL}}` with the Play link once approved.
+
+I run [opencode](https://github.com/sst/opencode) — an open-source AI coding agent — on my home server. It connects to Claude or GPT via my own API keys and edits code through tool calls: reading files, writing diffs, running shell commands.
+
+The workflow works well at my desk. Away from my desk, I had nothing useful. SSH into a terminal app loses the structured session UI. Generic AI chat apps know nothing about file diffs or tool-call approval. I wanted to actually *steer* a running session from my phone, not just read raw text output.
+
+So I built OpenCode Mobile.
+
+## What it is
+
+OpenCode Mobile is a React Native / Expo Android app. It's a thin client for the opencode HTTP + SSE API — no backend of mine between your phone and your server.
+
+You run opencode in server mode:
+
+```bash
+npm install -g opencode-ai
+OPENCODE_SERVER_PASSWORD=yourpassword opencode serve --hostname 0.0.0.0 --port 4096
+```
+
+Then in the app you paste the server URL — a local network IP, a Tailscale address, a Cloudflare Tunnel URL, whatever you already use to reach that machine. The app connects, lists your sessions, and streams output in real time.
+
+## What the UI gives you
+
+**Streaming chat.** Responses come in token by token via SSE — the same stream you'd see in the terminal, rendered in a mobile chat UI.
+
+**Diff viewer.** When the agent proposes a file change, you see an inline line-level diff — green additions, red removals — before the write happens.
+
+**Tool-call approval.** opencode pauses before executing file writes, shell commands, or other destructive actions and waits for explicit approval. The app surfaces this as a bottom sheet: approve or reject, and the agent proceeds or stops. This is the feature I personally find most useful — start a session, walk away, and only get pulled back when the agent needs a decision.
+
+**Session management.** Create, resume, switch between sessions.
+
+**Biometric unlock.** Face/fingerprint gates both app-open and individual message sends.
+
+## How it connects
+
+- **Local network** — phone and server on the same Wi-Fi
+- **Tailscale** — Tailscale IP works out of the box, no port forwarding
+- **Cloudflare Tunnel** — `cloudflared tunnel` gives you a public HTTPS URL
+- **ngrok** — same idea
+
+Each saved connection is stored in the Android Keystore via `expo-secure-store`. The URL and password never leave the device except to reach your server directly.
+
+## Model support
+
+opencode connects to whatever provider you configure: Anthropic Claude, OpenAI GPT, Google Gemini, or any local model behind an OpenAI-compatible API (ollama, LM Studio, llama.cpp). The mobile app doesn't care — it talks to opencode, and opencode talks to your model. Your API keys stay on your server.
+
+## Technical notes for the curious
+
+The trickiest part was SSE streaming. React Native lacks a native `EventSource`. The standard web polyfill mostly works, but Android's OkHttp follows redirects and drops the `Accept: text/event-stream` header on the hop, which breaks reconnects against tunneled servers. The fix is a custom fetch wrapper that sets the header on every hop and manages reconnect/backoff.
+
+The diff viewer is a custom line-level parser feeding a `FlatList`, not a WebView. This keeps dark-mode theming consistent and avoids the overhead of a full browser engine for rendering `+/-` lines.
+
+Tool-call approval required coordinating two async streams: the inbound SSE stream and the outbound user response. The solution is a React Query mutation that fires on approval plus an optimistic UI update that unblocks the stream client-side while the server confirms.
+
+## Open source
+
+MIT licensed. Source at [github.com/dzianisv/opencode-mobile](https://github.com/dzianisv/opencode-mobile). Issues and PRs welcome.
+
+Install ([all options on one page](https://dzianisv.github.io/opencode-mobile/download/)): add the self-hosted F-Droid repo `https://dzianisv.github.io/opencode-mobile/fdroid/repo` in your F-Droid client, or grab the [direct APK](https://github.com/dzianisv/opencode-mobile/releases/latest). Google Play is in review and going live shortly: {{PLAY_URL}}
+
+Landing page and setup guide: [dzianisv.github.io/opencode-mobile](https://dzianisv.github.io/opencode-mobile/)
+
+If you run opencode and try it, I'm especially interested in feedback on latency with local models — the streaming UI has a minimum render interval to avoid thrashing, and I don't know where that threshold feels wrong on slow hardware.

docs/marketing/product-hunt.md

@@ -0,0 +1,74 @@
+# Product Hunt — copy-paste ready
+
+> **Launch timing:** Submit at 12:01am PT. PH ranks by upvotes-per-day and the leaderboard resets at midnight PT, so launching the second the day opens maximizes your window. Avoid launching the same day as a huge consumer product (check the upcoming page first). Tue/Wed/Thu tend to be calmer than Mon.
+> **Hunter:** self-hunt is fine; a hunter with reach is a bonus but not required.
+> **First comment must be posted by you within the first minute** — it sets the narrative.
+> `{{PLAY_URL}}` = `https://play.google.com/store/apps/details?id=cc.agentlabs.opencode` once approved (PH lets you add the Play link as a product link on the day it goes live).
+
+---
+
+## Name
+
+```
+OpenCode Mobile
+```
+
+## Tagline (60 chars max)
+
+```
+Drive your self-hosted AI coding agent from your phone
+```
+(54 chars)
+
+## Topics / categories
+
+`Developer Tools` · `Android` · `Open Source` · `Artificial Intelligence`
+
+## Links
+
+- Website (primary): https://dzianisv.github.io/opencode-mobile/
+- Install (F-Droid + APK, one page): https://dzianisv.github.io/opencode-mobile/download/
+- GitHub: https://github.com/dzianisv/opencode-mobile
+- F-Droid repo: https://dzianisv.github.io/opencode-mobile/fdroid/repo
+- Direct APK: https://github.com/dzianisv/opencode-mobile/releases/latest
+- Google Play: {{PLAY_URL}}  *(add on launch day once approved)*
+
+---
+
+## Description
+
+OpenCode Mobile is the Android client for [opencode](https://github.com/sst/opencode) — the open-source AI coding agent. Connect to your own opencode server over local Wi-Fi, Tailscale, Cloudflare Tunnel, or ngrok, and control AI-powered coding sessions from anywhere.
+
+You get token-by-token streaming output, a full inline diff viewer for every file change the agent proposes, and an explicit tool-call approval UI so you decide what gets written or executed. Your code, your API keys, your server — the app is a pure thin client that never proxies your traffic through any backend of ours.
+
+Free and MIT licensed. No subscription, no ads, no telemetry you didn't opt into.
+
+---
+
+## First Comment (Maker Comment — post within 60 seconds)
+
+Hey Product Hunt! I'm the developer of OpenCode Mobile.
+
+I built this because I run long opencode sessions on my home server and needed a way to check in from my phone — not just to read output, but to actually approve tool calls and steer the agent. Terminal apps over SSH lose the session structure. Generic AI chat apps have no concept of file diffs or tool calls. So I built a proper native client.
+
+A few things worth knowing:
+
+- It's a client for [opencode](https://github.com/sst/opencode) (by the sst team, MIT). You need opencode running somewhere — laptop, home server, VPS. Setup is `npm install -g opencode-ai && opencode serve`, then paste the URL into the app.
+- Connect however you already reach home: local network, Tailscale, Cloudflare Tunnel, ngrok.
+- Works with any model opencode supports: Claude, GPT, Gemini, or local LLMs via any OpenAI-compatible endpoint. Your keys stay on your server.
+- MIT licensed, source public. Available now via a self-hosted F-Droid repo and a direct APK; Google Play is in review and going live shortly.
+
+Happy to answer anything — especially about the SSE streaming + tool-call approval flow, which was the trickiest part to get right. Thanks for checking it out!
+
+---
+
+## Gallery shot list (produce before launch — see ASSETS.md)
+
+1080×1920 portrait, dark theme, real app UI — no mockups:
+
+1. **Connection setup** — "Add Connection" with URL + password fields. Caption: "Connect to your own opencode server."
+2. **Active streaming session** — response mid-generation. Caption: "Token-by-token streaming from your server."
+3. **Diff viewer** — inline diff with green/red lines. Caption: "Review every file change before it lands."
+4. **Tool-call approval** — bottom sheet, pending shell command. Caption: "You approve every action the agent takes."
+5. **Session list** — multiple named sessions. Caption: "All your coding sessions in one place."
+6. **Hero / thumbnail** (1270×760) — dark bg (#0F172A), icon left, device showing streaming chat right, headline: "AI Coding Agent. In Your Pocket."

docs/marketing/reddit-localllama.md

@@ -0,0 +1,43 @@
+# r/LocalLLaMA — copy-paste ready
+
+> **Subreddit:** r/LocalLLaMA (~500k+ members, very active, technically sharp)
+> **Flair:** `Resources` or `Other` (this sub uses topic flairs, not "Project"; `Resources` fits a tool release best). If a `Tutorial`/`News` flair fits a future post, save those for the follow-up.
+> **Rules that matter here:** This community is allergic to cloud-first / closed products and to thin hype. Lead with the **bring-your-own / local-model** angle — emphasize that all inference stays on the user's hardware and the app is just a UI. No marketing voice; be a builder talking to builders. End with a real technical question to invite discussion (mods and users reward that, and it boosts comment count → ranking).
+> **Best time:** US daytime, but this sub is global and active late — 9am–1pm ET is safe.
+> `{{PLAY_URL}}` = `https://play.google.com/store/apps/details?id=cc.agentlabs.opencode` once approved.
+> **Sequencing:** Post this on a DIFFERENT day from r/selfhosted to avoid cross-post spam perception.
+
+---
+
+**Title:**
+
+```
+I built an Android app to control opencode from my phone — works with local LLMs via your existing opencode server config
+```
+
+**Body:**
+
+If you run [opencode](https://github.com/sst/opencode) with a local model (ollama, LM Studio, llama.cpp server, or any OpenAI-compatible endpoint), OpenCode Mobile gives you a real mobile client for those sessions.
+
+**The setup**
+
+opencode supports any OpenAI-compatible API via its provider config. Point it at your local model, run `opencode serve`, and the app connects over Tailscale / local network / tunnel. All inference stays on your hardware — the app is purely a UI. No keys, no prompts, and no model traffic ever go anywhere but between your phone and your box.
+
+**What you get on the phone**
+
+- Streaming output as your local model generates (token by token via SSE)
+- Inline diff viewer — see exactly what the agent is changing before approving
+- Tool-call approval UI — explicitly OK file writes and shell commands
+- Works with any model opencode supports: local LLMs, Claude, GPT, Gemini, or mixed
+- MIT licensed, biometric unlock, secrets in the Android Keystore
+
+**Source / install**
+
+- Source (MIT): https://github.com/dzianisv/opencode-mobile
+- Install (F-Droid + APK, one page): https://dzianisv.github.io/opencode-mobile/download/
+- All install options + guide: https://dzianisv.github.io/opencode-mobile/
+- F-Droid repo: https://dzianisv.github.io/opencode-mobile/fdroid/repo
+- Direct APK: https://github.com/dzianisv/opencode-mobile/releases/latest
+- Google Play: in review, live shortly — {{PLAY_URL}}
+
+I'm especially interested in feedback from people running local models: how does the streaming UI feel when tokens arrive at 3–5 tok/s on slower hardware? The renderer has a minimum repaint interval to avoid thrashing and I'm not sure the threshold is right for slow generation. Also curious which local backends people are pairing with opencode.

docs/marketing/reddit-selfhosted.md

@@ -0,0 +1,52 @@
+# r/selfhosted — copy-paste ready
+
+> **Subreddit:** r/selfhosted (~400k+ members)
+> **Flair:** `Release` (use Release for an app launch; if not available, use `Product Announcement`).
+> **Rules that matter here:** Self-promotion is allowed for your own project but must be genuinely self-hostable and you must be present to answer questions. Lead with the self-hosting angle, not the AI hype. No URL shorteners. Do NOT post the same title/body to multiple subreddits the same day (looks like spam and r/selfhosted mods notice).
+> **Best time:** Weekday mornings US Eastern (8–11am ET). This community skews US/EU.
+> `{{PLAY_URL}}` = `https://play.google.com/store/apps/details?id=cc.agentlabs.opencode` once Play approval lands.
+
+---
+
+**Title:**
+
+```
+OpenCode Mobile – Android client for your self-hosted opencode AI coding agent (MIT, no backend, your keys)
+```
+
+**Body:**
+
+I run [opencode](https://github.com/sst/opencode) on my home server for AI-assisted coding. Great at the desk — away from the desk, I had nothing. So I built a mobile client.
+
+**What it is**
+
+OpenCode Mobile connects to your *own* opencode server over whatever you already use to reach home — local Wi-Fi, Tailscale, Cloudflare Tunnel, or ngrok. You type the server URL into the app and that's your entire infrastructure footprint. No cloud service of mine ever touches your traffic.
+
+- Token-by-token streaming chat from your server
+- Inline diff viewer for every file change the agent proposes
+- Tool-call approval — you explicitly approve file writes and shell commands before they execute
+- Multiple saved connections (home server, VPS, work box)
+- Biometric unlock; connection secrets in the Android Keystore
+- MIT licensed, source on GitHub
+
+**What it is not**
+
+Not a standalone AI model. You need opencode running:
+
+```
+npm install -g opencode-ai
+OPENCODE_SERVER_PASSWORD=yourpassword opencode serve --hostname 0.0.0.0 --port 4096
+```
+
+Your API keys stay on your server. No accounts, no analytics, no proprietary backend. Sentry crash reporting is opt-in and off by default.
+
+**Install**
+
+- Install (F-Droid + APK, one page): https://dzianisv.github.io/opencode-mobile/download/
+- All options + setup guide: https://dzianisv.github.io/opencode-mobile/
+- F-Droid repo (add this URL in your F-Droid client): https://dzianisv.github.io/opencode-mobile/fdroid/repo
+- Direct APK: https://github.com/dzianisv/opencode-mobile/releases/latest
+- Source: https://github.com/dzianisv/opencode-mobile
+- Google Play: in review, going live shortly — {{PLAY_URL}}
+
+Happy to answer anything about the tunnel setup or the API. Feedback welcome, especially from anyone already self-hosting opencode.

docs/marketing/x-thread.md

@@ -0,0 +1,83 @@
+# X (Twitter) thread — copy-paste ready
+
+> Post as a native thread (write tweet 1, then "add another tweet" for 2–8). Don't paste links in tweet 1 — X suppresses reach on link-first tweets. Put the main link in the last tweet and/or the first reply.
+> Best windows: 9–11am ET or 1–3pm ET on weekdays.
+> After posting, quote-tweet your own thread later that day linking the HN/PH post for a second impression.
+> `{{PLAY_URL}}` = `https://play.google.com/store/apps/details?id=cc.agentlabs.opencode` once approved.
+
+---
+
+**Tweet 1 (hook)**
+```
+I built an Android app that connects to your self-hosted AI coding agent.
+
+Token-by-token streaming. Inline diff viewer. Tool-call approval — from your phone.
+
+OpenCode Mobile. MIT, free, no backend of mine.
+
+🧵
+```
+
+**Tweet 2 (the problem)**
+```
+The problem: opencode runs a long coding session on my server. I leave my desk.
+
+SSH + a terminal loses the session UX. Generic AI chat apps have no concept of file diffs or tool-call approval.
+
+I wanted a real client, not a workaround.
+```
+
+**Tweet 3 (how it works)**
+```
+How it works:
+
+opencode exposes an HTTP + SSE API. The app speaks it — streaming output, session state, diffs, tool calls.
+
+Your code stays on your server. Your provider keys stay on your server. The app is a thin client. No proxy, no middleman.
+```
+
+**Tweet 4 (features)**
+```
+What you get:
+
+→ Watch the agent generate code token by token
+→ See every file diff before it's written
+→ Approve or reject shell commands + file writes
+→ Manage multiple sessions
+→ Connect via Tailscale, Cloudflare Tunnel, ngrok, or local network
+```
+
+**Tweet 5 (local-model angle)**
+```
+Works with any model opencode supports: Claude, GPT, Gemini — or local LLMs via any OpenAI-compatible endpoint (ollama, LM Studio, llama.cpp).
+
+Your keys. Your hardware. Your inference budget.
+```
+
+**Tweet 6 (OSS / trust)**
+```
+MIT licensed. No subscription. No ads.
+
+Sentry crash reporting is opt-in and OFF by default. Connection secrets live in the Android Keystore.
+
+Source: github.com/dzianisv/opencode-mobile
+```
+
+**Tweet 7 (CTA)**
+```
+On Android now:
+
+Install (F-Droid + direct APK): dzianisv.github.io/opencode-mobile/download
+Setup guide: dzianisv.github.io/opencode-mobile/guide
+
+Google Play going live shortly: {{PLAY_URL}}
+
+If you run opencode, give it a try. Issues + PRs welcome.
+```
+
+**Tweet 8 (optional, post as reply for social proof)**
+```
+Also on Hacker News today if you want the technical deep-dive (SSE polyfill, WebView-free diff renderer, coordinating two async streams for approval):
+
+[paste HN link here after you post Show HN]
+```