memoir-cli 3.1.1 → 3.2.1

package/GAMEPLAN.md

@@ -0,0 +1,235 @@
+# Memoir Business Game Plan
+**Date:** March 25, 2026 | **Status:** Pre-revenue | **Author:** Boardroom consensus + CEO directive
+
+---
+
+## Current State
+
+| Metric | Value |
+|--------|-------|
+| Version | 3.1.2 (npm) |
+| Revenue | $0 |
+| Users | ~50 npm downloads |
+| AI Tools Supported | 11 (Claude, Gemini, Cursor, Copilot, Windsurf, Zed, Cline, Continue, Aider, Codex, ChatGPT) |
+| Cloud Backend | Supabase (auth + storage + PostgreSQL) |
+| Landing Page | memoir.sh (Vercel, 13 blog posts, no email capture) |
+| Blog Posts | 13 SEO-targeted articles |
+| Analytics | None (CLI or website) |
+| Payment Processing | None |
+| Team Features | None |
+| Shareable Links | None |
+
+---
+
+## What's Already Built (Don't Rebuild)
+
+- **CLI core** — push, restore, snapshot, resume, migrate, diff, profiles, doctor
+- **Cloud sync** — Supabase auth (email/password), gzipped bundles in Storage, PostgreSQL metadata
+- **Free/Pro tiers** — enforced in code (Free: 3 backups, Pro: 50) — but no way to pay for Pro
+- **Version history** — cloud backups versioned, restore from any version
+- **E2E encryption** — AES-256-GCM, async scrypt (just fixed), client-side before upload
+- **Workspace sync** — clones git repos, bundles non-git projects, applies uncommitted patches
+- **Session handoff** — snapshot current session, resume on another machine
+- **Landing page** — memoir.sh with animated terminal demo, tool marquee, FAQ, competitor comparison
+- **13 SEO blog posts** — sync guides for each tool, comparisons, setup guides
+
+---
+
+## The Plan: 4 Phases
+
+### Phase 1: Monetization Foundation (Week 1-2)
+> **Goal:** Accept money. Capture emails. Track usage.
+
+| Task | Priority | Effort | Details |
+|------|----------|--------|---------|
+| Add Stripe integration | P0 | 1 day | Connect to Pro tier ($15/mo individual, already priced in competitor comparison) |
+| `memoir upgrade` command | P0 | 0.5 day | Opens Stripe checkout from CLI, activates Pro |
+| Add pricing page to memoir.sh | P0 | 0.5 day | Free vs Pro vs Teams (coming soon) |
+| Add email capture / waitlist | P0 | 0.5 day | "Get notified for Teams" — collect emails on memoir.sh |
+| Add PostHog analytics to CLI | P1 | 0.5 day | Anonymous: commands used, tool count, machine OS, cloud vs local |
+| Add PostHog to memoir.sh | P1 | 0.5 day | Page views, blog reads, install clicks |
+| `memoir doctor` completion | P2 | 0.5 day | Finish the stubbed diagnostics command |
+
+**Phase 1 deliverable:** People can pay. We know who's using what.
+
+---
+
+### Phase 2: Viral Loop + Shareability (Week 3-4)
+> **Goal:** Every user brings one more user.
+
+| Task | Priority | Effort | Details |
+|------|----------|--------|---------|
+| Shareable context links | P0 | 2 days | `memoir share` → generates encrypted link (Supabase signed URL, 24hr expiry). Recipient runs `memoir restore --from <link>` |
+| Share landing page | P0 | 0.5 day | When link is opened in browser (not CLI), show "Install memoir to restore this context" with one-click copy |
+| Team invite flow | P1 | 1 day | `memoir team create`, `memoir team invite <email>` — shared backup namespace in Supabase |
+| Onboarding context | P1 | 0.5 day | `memoir push --share` generates a restore link printed to terminal. Copy-paste to Slack |
+| "Synced with memoir" badge | P2 | 0.5 day | Auto-append to CLAUDE.md / .cursorrules when synced — passive discovery |
+
+**Phase 2 deliverable:** Sharing is the viral loop. Every shared link = a new install prompt.
+
+---
+
+### Phase 3: Teams Tier (Week 5-8)
+> **Goal:** $29/seat/month revenue from dev teams.
+
+| Task | Priority | Effort | Details |
+|------|----------|--------|---------|
+| Organizations in Supabase | P0 | 2 days | `organizations` table, `org_members` table, role-based (admin/member) |
+| Shared team backups | P0 | 2 days | `memoir push --team` syncs to org namespace. All members can restore team context |
+| Team dashboard (web) | P1 | 3 days | memoir.sh/dashboard — see team members, backup history, storage usage |
+| Seat-based billing | P0 | 1 day | Stripe per-seat subscription, enforce in CLI |
+| Context inheritance | P1 | 1 day | `memoir restore --from <teammate>` — pull specific teammate's context with permission |
+| Audit log | P2 | 1 day | Who pushed, who restored, when — enterprise compliance checkbox |
+| SSO (Google/GitHub) | P2 | 1 day | Enterprise teams expect OAuth, not email/password |
+
+**Phase 3 deliverable:** Teams can buy seats, share context, see a dashboard.
+
+---
+
+### Phase 4: Enterprise + Moat (Week 9-12)
+> **Goal:** First $5k MRR. Lock-in through history depth.
+
+| Task | Priority | Effort | Details |
+|------|----------|--------|---------|
+| Context time-travel | P1 | 3 days | `memoir restore --version 5 --tool claude` — restore any tool to any point in history |
+| Diff between versions | P1 | 1 day | `memoir diff v3 v7` — show what changed in AI context between versions |
+| Context quality scoring | P2 | 2 days | Auto-tag backups: files changed, decisions made, session length. Surface "important" snapshots |
+| Enterprise pricing page | P1 | 0.5 day | $99/seat/month with SLA, priority support, SSO, audit logs |
+| SOC2 narrative | P2 | 1 day | Document E2E encryption, zero-knowledge architecture, audit trail for compliance conversations |
+| API for integrations | P2 | 3 days | REST API: programmatic backup/restore for CI/CD pipelines, onboarding scripts |
+
+**Phase 4 deliverable:** Enterprise-ready product with deep history moat.
+
+---
+
+## Pricing Structure
+
+| Tier | Price | Limits | Target |
+|------|-------|--------|--------|
+| **Free** | $0/forever | 3 cloud backups, local unlimited, 1 machine | Solo devs trying it out |
+| **Pro** | $15/month | 50 cloud backups, unlimited machines, version history | Power users, multi-machine devs |
+| **Teams** | $29/seat/month | Shared team context, dashboard, audit log, 200 backups/team | Dev teams (5-20 people) |
+| **Enterprise** | $99/seat/month | SSO, SLA, API access, compliance docs, unlimited backups | Companies (20+) |
+
+---
+
+## Positioning
+
+| Audience | Message |
+|----------|---------|
+| Individual dev | "Never lose your AI context again" |
+| Dev team lead | "Onboard devs in 60 seconds with full AI context" |
+| Enterprise buyer | "SOC2-ready AI workflow continuity" |
+| SEO / content | "Git for your AI setup" |
+
+**One-liner:** memoir syncs your AI memory across every machine and every teammate.
+
+**Anti-positioning (what we're NOT):** Not a dotfiles manager. Not VS Code Sync. Not a cloud IDE. We sync the AI layer — the conversations, decisions, and context that make your tools smart.
+
+---
+
+## First 100 Users Plan
+
+| Week | Action | Target |
+|------|--------|--------|
+| 1 | Ship Stripe + pricing page | Accept payments |
+| 2 | Post on r/programming, r/neovim, r/cursor, Hacker News | 500 page views |
+| 3 | Cold DM 50 developers who tweet about Claude/Cursor context loss | 10 installs |
+| 4 | Ship shareable links, post demo video on X/Twitter | 20 shares |
+| 5-6 | Reach out to 10 companies using Cursor (check their GitHub for .cursorrules) | 3 team pilots |
+| 7-8 | Ship Teams tier, convert pilots to paid | First $290 MRR |
+| 9-12 | Content marketing: "How Company X onboards devs in 60s" case study | 100 users, $1k+ MRR |
+
+---
+
+## Supabase Schema Changes Needed
+
+```sql
+-- Organizations
+CREATE TABLE organizations (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  name TEXT NOT NULL,
+  slug TEXT UNIQUE NOT NULL,
+  owner_id UUID REFERENCES auth.users(id),
+  plan TEXT DEFAULT 'teams',
+  stripe_customer_id TEXT,
+  stripe_subscription_id TEXT,
+  created_at TIMESTAMPTZ DEFAULT now()
+);
+
+-- Org members
+CREATE TABLE org_members (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  org_id UUID REFERENCES organizations(id) ON DELETE CASCADE,
+  user_id UUID REFERENCES auth.users(id),
+  role TEXT DEFAULT 'member' CHECK (role IN ('admin', 'member')),
+  invited_by UUID REFERENCES auth.users(id),
+  joined_at TIMESTAMPTZ DEFAULT now(),
+  UNIQUE(org_id, user_id)
+);
+
+-- Shared links
+CREATE TABLE shared_links (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  backup_id UUID REFERENCES backups(id),
+  created_by UUID REFERENCES auth.users(id),
+  token TEXT UNIQUE NOT NULL,
+  expires_at TIMESTAMPTZ NOT NULL,
+  max_uses INT DEFAULT 1,
+  use_count INT DEFAULT 0,
+  created_at TIMESTAMPTZ DEFAULT now()
+);
+
+-- Add org_id to backups for team backups
+ALTER TABLE backups ADD COLUMN org_id UUID REFERENCES organizations(id);
+
+-- Add stripe fields to subscriptions
+ALTER TABLE subscriptions ADD COLUMN stripe_customer_id TEXT;
+ALTER TABLE subscriptions ADD COLUMN stripe_subscription_id TEXT;
+ALTER TABLE subscriptions ADD COLUMN seats INT DEFAULT 1;
+```
+
+---
+
+## New CLI Commands Summary
+
+```
+memoir upgrade          # Open Stripe checkout, activate Pro
+memoir share            # Generate encrypted shareable link
+memoir team create      # Create a team organization
+memoir team invite      # Invite teammate by email
+memoir team list        # List team members
+memoir push --team      # Push to team namespace
+memoir restore --from   # Restore from shared link or teammate
+memoir history --diff   # Diff between backup versions
+memoir analytics        # Show your usage stats (local)
+```
+
+---
+
+## Risk Register
+
+| Risk | Likelihood | Impact | Mitigation |
+|------|-----------|--------|------------|
+| AI tools change config paths | High | Medium | Version-gated path detection, community PRs for new tools |
+| Supabase costs spike with users | Medium | Medium | Gzip compression (already done), enforce tier limits, monitor |
+| Nobody pays for Pro | High | High | Validate with shareable links first (free viral), watch conversion |
+| Enterprise competitor (JetBrains, GitHub) builds this | Medium | High | Move fast, own the CLI mindshare, community moat |
+| ToS violations syncing AI configs | Low | High | Only sync user-owned files (configs, not conversations). Document clearly |
+| Data breach of cloud backups | Low | Critical | E2E encryption means we literally can't read user data. Zero-knowledge by design |
+
+---
+
+## This Week's Checklist
+
+- [ ] Stripe account setup + integration in CLI
+- [ ] `memoir upgrade` command
+- [ ] Pricing page on memoir.sh
+- [ ] Email capture for Teams waitlist on memoir.sh
+- [ ] PostHog analytics on CLI (anonymous, opt-out available)
+- [ ] PostHog analytics on memoir.sh
+- [ ] Post in 3 subreddits about memoir
+
+---
+
+*"The CLI is the funnel. Cloud is the product. Teams is the business."*

package/LAUNCH_POSTS.md

@@ -0,0 +1,247 @@
+# Memoir Launch Posts — Ready to Copy & Paste
+
+---
+
+## 1. Hacker News — Show HN
+
+**Title:** Show HN: Memoir – Sync your AI coding memory across 11 tools and every device
+
+**Text:**
+
+I switch between a Mac and a PC daily. Every time, my Claude Code rules, Gemini instructions, Cursor settings — gone. Trapped in hidden dotfiles on whichever machine I used last.
+
+I built memoir to fix this. It's a CLI that backs up, restores, and syncs your AI memory across devices and tools. It supports 11 tools: Claude Code, Gemini CLI, ChatGPT, OpenAI Codex, Cursor, GitHub Copilot, Windsurf, Zed, Cline, Continue.dev, and Aider.
+
+```
+memoir push      # back up everything — AI configs, projects, session state
+memoir restore   # restore on any machine — AI picks up mid-conversation
+```
+
+What makes it different from dotfile managers:
+
+1. **AI-aware translation.** `memoir migrate --from claude --to cursor` uses AI to rewrite your instructions following each tool's conventions — not just file copy.
+
+2. **Session handoff.** memoir captures what you were doing (files changed, errors hit, decisions made) and injects it on restore so your AI picks up mid-conversation.
+
+3. **Workspace sync.** Git repos are auto-cloned, non-git projects are bundled, and uncommitted changes are saved as patches and reapplied.
+
+4. **MCP server.** `memoir mcp` gives your editor 6 tools to search, read, and save memories without leaving the conversation.
+
+5. **E2E encrypted.** AES-256-GCM. Secret scanning auto-redacts API keys and tokens before sync. Zero-knowledge — we can't read your data.
+
+It syncs three layers no other tool connects: AI memory (configs + instructions), session state (what you were doing), and workspace (your actual projects).
+
+```
+npm install -g memoir-cli
+```
+
+~100kb installed. MIT licensed. Cloud sync available (free tier: 3 backups). Would love feedback — especially on what workflows you'd want next. Thinking about shareable context links so you can onboard a teammate with one URL.
+
+https://github.com/camgitt/memoir
+
+---
+
+## 2. Reddit — r/programming
+
+**Title:** I built a CLI that syncs your AI coding memory across 11 tools and every device
+
+**Body:**
+
+Every AI coding tool stores your preferences in its own hidden config files. Claude has `~/.claude/` and `CLAUDE.md`. Cursor has `.cursorrules`. Gemini has `GEMINI.md`. None of them talk to each other, and none of them sync between machines.
+
+I got tired of re-teaching my AI tools every time I switched from my Mac to my PC, so I built **memoir** — a CLI that backs up, restores, and translates your AI memory across devices and tools.
+
+**What it does:**
+
+- `memoir push` — backs up AI configs, project knowledge, and your current coding session
+- `memoir restore` — restores everything on any machine (Mac, Windows, Linux)
+- `memoir migrate --from claude --to cursor` — AI-powered translation between tools (rewrites conventions, doesn't just copy files)
+- `memoir mcp` — MCP server so your editor can search/save memories in-conversation
+
+**What makes it interesting:**
+
+It doesn't just sync config files. It captures *session state* — what files you changed, what decisions you made, what you were debugging — and injects that context when you restore. Your AI literally picks up where you left off.
+
+It also syncs your actual workspace: git repos are auto-cloned, non-git projects are bundled and unpacked, uncommitted changes are saved as patches.
+
+E2E encrypted (AES-256-GCM), secret scanning built in, MIT licensed.
+
+```
+npm install -g memoir-cli
+```
+
+GitHub: https://github.com/camgitt/memoir
+Website: https://memoir.sh
+
+Would love to hear what workflows people would find useful. Currently thinking about shareable context links for team onboarding.
+
+---
+
+## 3. Reddit — r/cursor
+
+**Title:** Sync your .cursorrules and AI context across machines (and 10 other AI tools)
+
+**Body:**
+
+Quick question for multi-machine Cursor users — how are you keeping your `.cursorrules` and settings in sync across devices?
+
+I built **memoir** because I kept losing my AI context switching between machines. It's a CLI that syncs Cursor configs alongside 10 other AI tools — Claude Code, Gemini CLI, ChatGPT, Codex, Copilot, Windsurf, Zed, Cline, Continue.dev, and Aider. 11 tools total.
+
+The part that's been most useful for me:
+
+```
+memoir migrate --from claude --to cursor
+```
+
+This uses AI to actually *translate* your Claude CLAUDE.md into a proper `.cursorrules` that follows Cursor's conventions. Not a file copy — a real rewrite.
+
+It also captures your current coding session and lets you resume on another machine. Your AI picks up mid-conversation.
+
+```
+npm install -g memoir-cli
+memoir init
+memoir push     # backs up .cursorrules + settings + projects
+memoir restore  # restores everything on another machine
+```
+
+E2E encrypted, MIT licensed, free tier available.
+
+GitHub: https://github.com/camgitt/memoir
+
+What other Cursor-specific workflows would be useful? Happy to add things.
+
+---
+
+## 4. Reddit — r/neovim
+
+**Title:** memoir — sync your AI coding context (Aider, Cline, Continue.dev) across machines from the terminal
+
+**Body:**
+
+For terminal-first devs using AI tools alongside Neovim — I built a CLI that syncs your AI memory across machines and tools.
+
+If you're using Aider, Cline, or Continue.dev, you've probably got config files and project instructions scattered across `~/.aider.conf.yml`, `.clinerules`, `.continuerules`, etc. memoir backs all of that up and restores it on any machine.
+
+```
+memoir push      # backs up AI configs + projects + session state
+memoir restore   # restores on any machine
+memoir migrate --from aider --to cline  # AI-powered translation
+```
+
+It also ships an MCP server (`memoir mcp`) that gives your tools 6 commands to search, read, and save memories without leaving your workflow.
+
+The workspace sync is nice too — git repos auto-clone, non-git projects get bundled, uncommitted changes are saved as patches and reapplied.
+
+Everything's E2E encrypted (AES-256-GCM) with secret scanning. MIT licensed.
+
+```
+npm install -g memoir-cli
+```
+
+https://github.com/camgitt/memoir
+
+Would love feedback from the terminal crowd. What AI tool integrations would you want to see next?
+
+---
+
+## 5. X/Twitter Launch Thread
+
+**Tweet 1 (hook):**
+AI tools forget you every time you switch machines.
+
+I built memoir — a CLI that syncs your AI memory across 11 tools and every device.
+
+One command to save. One command to restore. Your AI picks up mid-conversation.
+
+Here's what it does 🧵
+
+**Tweet 2:**
+The problem: Claude has CLAUDE.md. Cursor has .cursorrules. Gemini has GEMINI.md.
+
+None of them sync. None of them talk to each other.
+
+Switch machines? Start from zero. Switch tools? Re-teach everything.
+
+memoir fixes this.
+
+**Tweet 3:**
+```
+memoir push      # save everything
+memoir restore   # restore anywhere
+```
+
+It syncs three layers:
+→ AI memory (configs across 11 tools)
+→ Session state (what you were doing)
+→ Workspace (your actual projects)
+
+**Tweet 4:**
+The killer feature: AI-powered translation between tools.
+
+```
+memoir migrate --from claude --to cursor
+```
+
+This doesn't just copy files. It rewrites your Claude instructions into proper .cursorrules following Cursor's conventions.
+
+Works between all 11 tools.
+
+**Tweet 5:**
+Session handoff is the other thing nothing else does.
+
+memoir captures what files you changed, what decisions you made, what you were debugging.
+
+On restore, it injects that context. Your AI literally picks up where you left off.
+
+**Tweet 6:**
+Security:
+→ E2E encrypted (AES-256-GCM)
+→ Secret scanning catches API keys, tokens, passwords
+→ Auto-redacted before sync
+→ Zero-knowledge — we can't read your data
+
+**Tweet 7:**
+```
+npm install -g memoir-cli
+```
+
+Free & open source. MIT licensed. ~100kb.
+
+Cloud sync available. MCP server included so your editor can search memories in-conversation.
+
+GitHub: github.com/camgitt/memoir
+Website: memoir.sh
+
+Try it and let me know what you think ↓
+
+---
+
+## Posting Strategy
+
+### Timing
+- **Hacker News:** Tuesday or Wednesday, 8-9am ET (peak HN traffic)
+- **Reddit r/programming:** Same day as HN, 2-3 hours after
+- **Reddit r/cursor:** Day after HN post
+- **Reddit r/neovim:** Day after HN post (different audience, won't cannibalize)
+- **X/Twitter thread:** Same day as HN, post in the morning, then reply-thread throughout the day
+
+### Engagement Rules
+1. **Reply to every comment** within the first 2 hours — HN and Reddit rank by early engagement
+2. **Don't be defensive** — if someone says "this is just dotfiles," acknowledge it and explain the session handoff + translation layer
+3. **Ask questions back** — "What tools are you using?" and "What would you want synced?" drives comments
+4. **Have a demo GIF ready** — link to your demo.gif in early replies
+5. **Upvote timing** — ask 2-3 friends to upvote within the first 30 minutes (critical for HN front page)
+
+### Expected Objections & Responses
+
+**"This is just a dotfiles manager"**
+→ "Dotfiles managers sync files. memoir syncs AI context — it captures your session state (what you were debugging, what decisions you made) and injects it on restore. It also translates between tools using AI, not file copy. The workspace sync with uncommitted patches is a layer above dotfiles too."
+
+**"Why not just use git?"**
+→ "Git syncs code. memoir syncs the AI layer on top of it — your CLAUDE.md, .cursorrules, session context, and tool configs. Plus it handles non-git projects (bundles them), and saves uncommitted work as patches. It's the layer between your code and your AI."
+
+**"I don't use multiple machines"**
+→ "Fair — but do you use multiple AI tools? `memoir migrate` translates your context between them. And the MCP server is useful on a single machine for searching across all your AI memories."
+
+**"Security concerns with syncing AI configs"**
+→ "E2E encrypted before it leaves your machine (AES-256-GCM). Built-in secret scanner catches API keys, tokens, passwords — auto-redacted. Zero-knowledge architecture. Run `memoir doctor` to see exactly what gets synced."

package/MARKETING.md

@@ -0,0 +1,143 @@
+# memoir Marketing Plan
+
+## Key Metric
+Weekly active `memoir_recall` calls. Not installs, not stars, not waitlist. If AI tools are calling memoir_recall regularly, the product is working.
+
+---
+
+## Phase 1: Directory Listings (Week 1)
+
+### 1. awesome-mcp-servers PR
+**Repo:** https://github.com/punkpeye/awesome-mcp-servers (or appcypher)
+**PR title:** Add Memoir to Development Tools
+**Line to add** (alphabetical, between Mastra and Maven):
+```
+- [Memoir](https://github.com/camgitt/memoir) - Persistent memory for AI coding tools via MCP. Your AI remembers across sessions, tools, and machines
+```
+
+### 2. mcp.so Submission
+**Submit:** https://github.com/chatmcp/mcpso/issues/new
+**Title:** Add Memoir — persistent memory MCP server for AI coding tools
+**Body:**
+
+```
+## Server Info
+- **Name:** memoir-cli
+- **Repository:** https://github.com/camgitt/memoir
+- **npm:** https://www.npmjs.com/package/memoir-cli
+- **Website:** https://memoir.sh
+- **Author:** camgitt
+- **License:** MIT
+- **Language:** JavaScript (ESM)
+- **Transport:** stdio
+
+## Description
+MCP server that gives AI coding tools persistent memory across sessions. Your AI can search, read, and save memories automatically. Works with Claude Code, Cursor, Windsurf, and any MCP-compatible client.
+
+## MCP Tools
+| Tool | Description |
+|------|-------------|
+| `memoir_recall` | Search across all AI memories |
+| `memoir_remember` | Save context for future sessions |
+| `memoir_read` | Read a specific memory file |
+| `memoir_list` | List all memory files by tool |
+| `memoir_status` | Show detected AI tools |
+| `memoir_profiles` | Switch work/personal profiles |
+
+## Installation
+npm install -g memoir-cli
+
+## Client Setup
+Add to ~/.mcp.json:
+{ "mcpServers": { "memoir": { "command": "memoir-mcp" } } }
+
+## Tags
+memory, mcp, ai-tools, developer-tools, persistent-context, cli, claude, cursor
+```
+
+### 3. PulseMCP
+**Submit:** https://www.pulsemcp.com/submit
+Fill in: name, GitHub URL, npm URL, description.
+
+### 4. Smithery.ai
+```bash
+npx smithery auth login
+npx smithery mcp publish "https://github.com/camgitt/memoir" -n @camgitt/memoir
+```
+
+### 5. Official MCP Registry
+Requires adding `mcpName` to package.json and using mcp-publisher CLI.
+```bash
+npx @anthropic/mcp-publisher init
+npx @anthropic/mcp-publisher publish
+```
+
+---
+
+## Phase 2: Launch Posts (Week 1-2)
+
+### Show HN
+See SHOW_HN.md. Post Tuesday or Wednesday 8-10am ET.
+
+### Reddit Posts (1 per sub, spread across 3 days)
+
+**r/ClaudeAI:**
+Title: I built an MCP server that gives Claude long-term memory across sessions
+Body: "Got tired of re-explaining my project to Claude every conversation. Built an MCP server called memoir that lets Claude search and save memories automatically. Tell it your auth setup once — it remembers next week. Free, open source, MIT licensed. Works with Cursor and 9 other tools too. https://github.com/camgitt/memoir Would love feedback."
+
+**r/cursor:**
+Title: MCP server that syncs your project context between Cursor, Claude Code, and other tools
+Body: "Built memoir — an MCP server that gives your AI tools shared memory. You explain something in Cursor, and Claude Code knows it too. Also handles migrating your .cursorrules to other tools. Free CLI, MIT licensed. https://github.com/camgitt/memoir"
+
+**r/ChatGPTCoding:**
+Title: Open source tool that gives AI coding tools persistent memory (works with 11 tools)
+Body: "memoir is an MCP server + CLI that syncs your AI memory across Claude, Cursor, ChatGPT, Gemini, and 7 more tools. Your AI remembers your codebase across sessions. Also backs up all your AI configs and restores them on a new machine in 60 seconds. https://memoir.sh"
+
+---
+
+## Phase 3: Social + Content (Week 2-3)
+
+### X/Twitter Clips
+- 15-sec screen recording: memoir_recall in Claude Code
+- 15-sec screen recording: memoir migrate from Cursor to Claude
+- 15-sec screen recording: memoir restore on a fresh machine
+- Post across AlgoThesis + personal accounts
+
+### Blog Post
+Title: "How MCP Gives Your AI Tools Persistent Memory"
+Target keywords: "MCP memory server", "Claude Code memory", "AI coding context"
+Publish on memoir.sh/blog, cross-post to dev.to
+
+---
+
+## Phase 4: First 10 Users (Week 2-3)
+
+### Discord Communities
+- Claude Code official Discord
+- Cursor community Discord
+- AI/ML Discord servers
+- Don't promote — ask for feedback: "Building an MCP memory layer, would love testers"
+
+### Direct Outreach
+- Find people complaining about AI context loss on Twitter/Reddit
+- Reply with genuine help, mention memoir if relevant
+- Not spammy — just useful
+
+---
+
+## NOT Doing Yet
+- Stripe/payments (need users first)
+- Product Hunt (low conversion for CLI tools)
+- Teams tier (need solo users first)
+- Paid ads (premature)
+- Conference talks (too early)
+
+---
+
+## Timeline
+| Week | Focus | Goal |
+|------|-------|------|
+| 1 | Directory listings + Show HN | Listed in 5+ directories, 50+ stars |
+| 2 | Reddit + Discord + X clips | 10 active users |
+| 3 | Blog post + iterate on feedback | 25 active users, first feature from user feedback |
+| 4 | Repeat what worked, double down | 50+ weekly memoir_recall calls |