social-autoposter 1.1.0 → 1.1.2

package/README.md

@@ -2,6 +2,8 @@
 
 Automated social posting pipeline for Reddit, X/Twitter, LinkedIn, and Moltbook. Install as an AI agent skill or use the standalone Python scripts.
 
+The current storage backend is Neon Postgres via `DATABASE_URL` in `~/social-autoposter/.env`. Any legacy `database` key in old local configs or leftover `*.db` files are not used by the current scripts.
+
 ## Install as a skill
 
 ```bash

package/SKILL.md

@@ -1,148 +1,120 @@
 ---
 name: social-autoposter
-description: "Automate social media posting across Reddit, X/Twitter, LinkedIn, and Moltbook. Find threads, post comments, track engagement stats, and handle reply engagement. Use when: 'post to social', 'social autoposter', 'find threads', 'audit social posts', 'update post stats', 'engage replies'. Run /social-autoposter to start."
+description: "Automate social media posting across Reddit, X/Twitter, LinkedIn, and Moltbook. Find threads, post comments, create original posts, track engagement stats. Use when: 'post to social', 'social autoposter', 'find threads to comment on', 'create a post', 'audit social posts', 'update post stats', or after completing any task (mandatory per CLAUDE.md)."
 user_invocable: true
 ---
 
 # Social Autoposter
 
-Automates finding, posting, and tracking social media comments. Works with any agent that has browser automation and shell access.
+Automates finding, posting, and tracking social media comments and original posts across Reddit, X/Twitter, LinkedIn, and Moltbook.
 
 ## Quick Start
 
 | Command | What it does |
 |---------|-------------|
-| `/social-autoposter` | Full posting run (find threads + post + log) |
+| `/social-autoposter` | Comment run — find threads + post comment + log (cron-safe) |
+| `/social-autoposter post` | Create an original post/thread (manual only, never cron) |
 | `/social-autoposter stats` | Update engagement stats via API |
 | `/social-autoposter engage` | Scan and reply to responses on our posts |
 | `/social-autoposter audit` | Full browser audit of all posts |
 
-## Config
+**View your posts live:** `https://s4l.ai/stats/[your_handle]`
+— e.g. `https://s4l.ai/stats/m13v_` (Twitter handle without `@`), `https://s4l.ai/stats/Deep_Ad1959` (Reddit), `https://s4l.ai/stats/matthew-autoposter` (Moltbook).
+The handles come from `config.json → accounts.*.handle/username`. Each platform account has its own URL.
 
-All personal settings live in `config.json` (copy from `config.example.json`). The skill reads this at runtime.
-
-Key fields:
-- `accounts` — platform usernames/handles
-- `subreddits` — target subreddits to monitor
-- `content_angle` — your unique perspective for authentic comments
-- `projects` — your products/repos to mention when relevant (with topic keywords)
-- `database` — unused (DB is Neon Postgres via `DATABASE_URL` in `.env`)
-
-## Helper Scripts
+---
 
-Standalone Python scripts any agent can call directly. No LLM needed for these.
+## FIRST: Read config
 
-| Script | What it does |
-|--------|-------------|
-| `scripts/find_threads.py` | Find candidate threads via Reddit JSON + Moltbook API |
-| `scripts/scan_replies.py` | Scan for new replies to our posts via API |
-| `scripts/update_stats.py` | Fetch engagement stats via API, update DB |
+Before doing anything, read `~/social-autoposter/config.json`. Everything — accounts, projects, subreddits, content angle — comes from there.
 
-Examples:
 ```bash
-python3 scripts/find_threads.py --topic "macOS automation" --limit 5
-python3 scripts/scan_replies.py
-python3 scripts/update_stats.py --quiet
+cat ~/social-autoposter/config.json
 ```
 
----
-
-## Critical: No Parallel Posting
+Key fields you'll use throughout every workflow:
 
-**NEVER launch multiple agents or parallel tasks for posting.** All posting operations (comments, replies, thread creation) MUST be done sequentially in a single agent. Reasons:
-- There is only one shared browser — parallel agents fight over it and cause timeouts
-- Parallel agents cause duplicate posts (same comment posted twice on the same thread)
-- Browser lock conflicts lead to unpredictable failures
-
-This applies to ALL posting workflows: comments on existing threads, self-replies with links, new thread creation, and reply engagement. Even if you have 5 threads to post on, do them one at a time in the same agent.
+- `accounts.reddit.username` — Reddit handle to post as
+- `accounts.twitter.handle` — X/Twitter handle
+- `accounts.linkedin.name` — LinkedIn display name
+- `accounts.moltbook.username` — Moltbook username
+- `subreddits` — list of subreddits to monitor and post in
+- `content_angle` — the user's unique perspective for writing authentic comments
+- `projects` — products/repos to mention naturally when relevant (each has `name`, `description`, `website`, `github`, `topics`)
+- `database` — unused (DB is Neon Postgres via `DATABASE_URL` in `.env`)
 
-**After each post, always verify** by reloading the page and confirming the comment appears exactly once before moving to the next post.
+Use these values everywhere below instead of any hardcoded names or links.
 
 ---
 
-## Workflow: Post (`/social-autoposter`)
-
-Find a thread, draft a comment, post it, log it.
+## Helper Scripts
 
-### 1. Rate limit check
+Standalone Python scripts — no LLM needed.
 
-```sql
-SELECT COUNT(*) FROM posts WHERE posted_at >= NOW() - INTERVAL '24 hours'
+```bash
+python3 ~/social-autoposter/scripts/find_threads.py --include-moltbook
+python3 ~/social-autoposter/scripts/scan_replies.py
+python3 ~/social-autoposter/scripts/update_stats.py --quiet
 ```
-If 40+ posts in the last 24 hours, stop. Max 40/day.
 
-### 2. Find candidate threads
+---
+
+## Workflow: Post (`/social-autoposter`)
+
+### 1. Find candidate threads
 
-**Option A — Use the helper script (preferred, no browser needed):**
+**Option A — Script (preferred):**
 ```bash
-python3 scripts/find_threads.py --include-moltbook
+python3 ~/social-autoposter/scripts/find_threads.py --include-moltbook
 ```
-This returns a JSON list of candidate threads with dedup already applied.
 
-**Option B — Browse manually with browser automation:**
-Browse `/new` and `/hot` across target subreddits (from `config.json`). Also check Moltbook via API.
+**Option B — Browse manually:**
+Browse `/new` and `/hot` on the subreddits from `config.json`. Also check Moltbook via API.
 
-### 3. Pick the best thread
+### 2. Pick the best thread
 
-Requirements:
-- You have a genuine angle from your `content_angle` in `config.json`
-- The thread hasn't been posted in before (check `thread_url` in DB)
-- Your last 5 comments don't repeat the same talking points:
+- You have a genuine angle from `content_angle` in config.json
+- Not already posted in: `SELECT thread_url FROM posts`
+- Last 5 comments don't repeat the same talking points:
   ```sql
   SELECT our_content FROM posts ORDER BY id DESC LIMIT 5
   ```
-- If no thread fits naturally, **stop**. Better to skip than force a bad comment.
+- If nothing fits naturally, **stop**. Better to skip than force a bad comment.
 
-### 4. Read the thread
+### 3. Read the thread + top comments
 
-Before commenting, read the full thread:
-- Check tone (casual/technical/professional)
-- Read top comments for length and style cues
-- Note thread age (skip stale threads)
-- Identify the best comment to reply to (high-upvote comments get more visibility)
+Check tone, length cues, thread age. Find best comment to reply to (high-upvote comments get more visibility).
 
-### 5. Draft the comment
+### 4. Draft the comment
 
-Follow the **Content Rules** section below. Key points:
-- 2-3 sentences max, match thread energy
-- First person, specific details from your experience
-- No product links in top-level comments (use Tiered Reply Strategy for that)
-- If it sounds like a blog post, rewrite it
+Follow Content Rules below. 2-3 sentences, first person, specific details from `content_angle`. No product links in top-level comments.
 
-### 6. Post it
+### 5. Post it
 
 **Reddit** (browser automation):
 - Navigate to `old.reddit.com` thread URL
-- Find the reply box (textarea with class `usertext-edit`)
-- Type the comment, click submit
-- Wait 2-3 seconds, verify the comment appeared
-- Capture the permalink of the new comment
-- Close the tab
+- Reply box → type comment → submit → wait 2-3s → verify comment appeared → capture permalink → close tab
+- Post as the username in `config.json → accounts.reddit.username`
 
 **X/Twitter** (browser automation):
-- Navigate to the tweet
-- Type reply in the reply box, click Reply
-- Verify the reply posted
-- Capture the URL
+- Navigate to tweet → reply box → type → Reply → verify → capture URL
+- Post as the handle in `config.json → accounts.twitter.handle`
 
 **LinkedIn** (browser automation):
-- Navigate to the post
-- Type comment, click Post
-- No stable URL available, note as posted
+- Navigate to post → comment box → type → Post → close tab
+- Post as the name in `config.json → accounts.linkedin.name`
 
 **Moltbook** (API — no browser needed):
 ```bash
 source ~/social-autoposter/.env
-curl -s -X POST -H "Authorization: Bearer $MOLTBOOK_API_KEY" \
-  -H "Content-Type: application/json" \
+curl -s -X POST -H "Authorization: Bearer $MOLTBOOK_API_KEY" -H "Content-Type: application/json" \
   -d '{"title": "...", "content": "...", "type": "text", "submolt_name": "general"}' \
   "https://www.moltbook.com/api/v1/posts"
 ```
+On Moltbook: write as agent ("my human" not "I"). Max 1 post per 30 min.
 Verify: fetch post by UUID, check `verification_status` is `"verified"`.
-On Moltbook, write as an agent: "my human" not "I".
-Rate limit: max 1 post per 30 minutes.
 
-### 7. Log to database
+### 7. Log + sync
 
 ```sql
 INSERT INTO posts (platform, thread_url, thread_author, thread_author_handle,
@@ -151,163 +123,169 @@ INSERT INTO posts (platform, thread_url, thread_author, thread_author_handle,
 VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, 'active', NOW());
 ```
 
+Use the account value from `config.json` for `our_account`.
+
+If `sync_script` is set in config.json, run it after logging.
+
 ---
 
-## Workflow: Stats (`/social-autoposter stats`)
+## Workflow: Create Post (`/social-autoposter post`)
 
-Update engagement metrics for all posts. No browser needed.
+**Manual only — never run from cron.** Original posts are high-stakes and need human review.
 
-**Preferred: use the helper script:**
-```bash
-python3 scripts/update_stats.py
-python3 scripts/update_stats.py --quiet   # summary only
-python3 scripts/update_stats.py --json    # machine-readable output
+### 1. Cross-posting check
+
+```sql
+SELECT platform, thread_title, posted_at FROM posts
+WHERE source_summary LIKE '%' || %s || '%' AND posted_at >= NOW() - INTERVAL '30 days'
+ORDER BY posted_at DESC;
 ```
 
-This fetches:
-- **Reddit**: comment scores and thread stats via public JSON API. Detects deleted/removed.
-- **Moltbook**: upvotes and comment counts via REST API. Detects deleted posts.
+**NEVER post the same or similar content to multiple subreddits.** This is the #1 AI detection red flag. Each post must be unique to its community.
 
-Updates `upvotes`, `comments_count`, `thread_engagement`, `engagement_updated_at` in the DB.
+### 3. Pick one target community
 
-For **X/Twitter** stats (requires browser): use `/social-autoposter audit` instead.
+Choose the single best subreddit from `config.json → subreddits` for this topic. Tailor the post to that community's culture and tone.
 
----
+### 4. Draft the post
 
-## Workflow: Engage (`/social-autoposter engage`)
+**Anti-AI-detection checklist** (must pass ALL before posting):
+
+- [ ] No em dashes (—). Use regular dashes (-) or commas instead
+- [ ] No markdown headers (##) or bold (**) in Reddit posts
+- [ ] No numbered/bulleted lists — write in paragraphs
+- [ ] No "Hi everyone" or "Hey r/subreddit" openings
+- [ ] Title doesn't use clickbait patterns ("What I wish I'd known", "A guide to")
+- [ ] Contains at least one imperfection: incomplete thought, casual aside, informality
+- [ ] Reads like a real person writing on their phone, not an essay
+- [ ] Does NOT link to any project in the post body — earn attention first
+- [ ] Not too long — 2-4 short paragraphs max for Reddit
+
+**Read it out loud.** If it sounds like a blog post or a ChatGPT response, rewrite it.
+
+### 5. Post it
+
+**Reddit**: old.reddit.com → Submit new text post → paste title + body → submit → verify → capture permalink.
+
+### 6. Log it
+
+```sql
+INSERT INTO posts (platform, thread_url, thread_author, thread_author_handle,
+  thread_title, thread_content, our_url, our_content, our_account,
+  source_summary, status, posted_at)
+VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, 'active', NOW());
+```
+
+For original posts: `thread_url` = `our_url`, `thread_author` = our account from config.json.
 
-Discover replies to our posts and respond to them.
+### 7. Mandatory engagement plan
 
-### Phase A: Scan for replies (no browser needed)
+After posting, you MUST:
+- Check for comments within 2-4 hours
+- Reply to every substantive comment within 24 hours
+- Replies should be casual, conversational, expand the topic — NOT polished paragraphs
+- If someone accuses the post of being AI: respond genuinely, mention a specific personal detail
+
+---
+
+## Workflow: Stats (`/social-autoposter stats`)
 
 ```bash
-python3 scripts/scan_replies.py
+python3 ~/social-autoposter/scripts/update_stats.py
 ```
 
-This scans Reddit JSON API + Moltbook API for new replies. Inserts into `replies` table as `pending` or `skipped`.
+After running, view updated stats at `https://s4l.ai/stats/[handle]`. The DB syncs to Neon Postgres via `syncfield.sh` (called automatically by `stats.sh`). Changes appear on the website within ~5 minutes.
+
+---
+
+## Workflow: Engage (`/social-autoposter engage`)
 
-Skip reasons: `too_short` (<5 words), `filtered_author` (AutoModerator, [deleted], self), `too_old` (>7 days), `deleted`.
+### Phase A: Scan for replies (no browser)
+```bash
+python3 ~/social-autoposter/scripts/scan_replies.py
+```
 
-### Phase B: Respond to pending replies (needs browser/API)
+### Phase B: Respond to pending replies
 
-Query pending replies:
 ```sql
 SELECT r.id, r.platform, r.their_author, r.their_content, r.their_comment_url,
        r.depth, p.thread_title, p.our_content
-FROM replies r
-JOIN posts p ON r.post_id = p.id
-WHERE r.status='pending'
-ORDER BY r.discovered_at ASC LIMIT 10
+FROM replies r JOIN posts p ON r.post_id = p.id
+WHERE r.status='pending' ORDER BY r.discovered_at ASC LIMIT 10
 ```
 
-For each pending reply:
-1. Draft a response (2-4 sentences, casual, expand the topic, ask follow-ups)
-2. Apply the **Tiered Reply Strategy** for project mentions
-3. Post via browser (Reddit/X) or API (Moltbook)
-4. Update the reply record:
-   ```sql
-   UPDATE replies SET status='replied', our_reply_content=%s, our_reply_url=%s,
-     replied_at=NOW() WHERE id=%s
-   ```
+Draft replies: 2-4 sentences, casual, expand the topic. Apply Tiered Reply Strategy. Max 5 replies per run.
 
-Max 5 replies per run.
+Post via browser (Reddit/X) or API (Moltbook). Update:
+```sql
+UPDATE replies SET status='replied', our_reply_content=%s, our_reply_url=%s,
+  replied_at=NOW() WHERE id=%s
+```
 
 ### Phase C: X/Twitter replies (browser required)
 
-X has no public API for notifications. To discover X replies:
-1. Navigate to `https://x.com/notifications/mentions`
-2. Extract mentions replying to your account
-3. Filter out already-tracked reply IDs, light acknowledgments, and your own replies
-4. Respond to substantive replies (max 5)
-5. Log everything to `replies` table
+Navigate to `https://x.com/notifications/mentions`. Find replies to the handle in config.json. Respond to substantive ones (max 5). Log to `replies` table.
 
 ---
 
 ## Workflow: Audit (`/social-autoposter audit`)
 
-Full browser-based audit of all posts. Use for X/Twitter stats or visual verification.
-
-1. Query all posts with URLs:
-   ```sql
-   SELECT id, platform, our_url, status, upvotes, views, comments_count
-   FROM posts WHERE our_url IS NOT NULL ORDER BY posted_at DESC
-   ```
-
-2. Visit each URL via browser automation. Check:
-   - `active`: visible and accessible
-   - `deleted`: 404 or "this tweet has been deleted"
-   - `removed`: marked as removed by moderator
-   - `inactive`: thread locked or archived
-
-3. Capture engagement metrics (upvotes, views, comments) and update DB.
-
-4. Report summary: total checked, by status, top performers.
+Visit each post URL via browser. Check status (active/deleted/removed/inactive). Update engagement metrics. Report summary.
 
 ---
 
 ## Content Rules
 
-1. **Write like you're texting a coworker.** Lowercase fine. Sentence fragments fine. Never start with "Makes sense" or "The nuance here is." If it sounds like a blog post, rewrite it.
-
-2. **First person, specific.** Use concrete numbers and real experiences, not generalizations. Say "I" not "you" or "one."
-
-3. **Reply to top comments, not just OP.** High-upvote comments get more eyeballs.
-
-4. **Only comment when you have a real angle from your work.** Use `content_angle` from `config.json`. If the thread doesn't connect to your experience, skip it.
+### Tone & Voice
 
-5. **No product links in top-level comments.** Earn attention first. Links come later via the Tiered Reply Strategy.
+1. **Write like you're texting a coworker.** Lowercase fine. Sentence fragments fine. Never start with "Makes sense" or "The nuance here is." If it sounds like a blog post, rewrite it.
+2. **First person, specific.** Use concrete details from `content_angle` in config.json. Real numbers, real experiences, not generalizations.
+3. **Reply to top comments, not just OP.**
+4. **Only comment when there's a genuine angle from the user's work.** Use `content_angle` from config.json. If the thread doesn't connect, skip it.
+5. **No product links in top-level comments or original posts.** Earn attention first. Only link in deeper replies when someone asks.
+6. **On Moltbook, write as an agent.** "my human" not "I".
+7. **Log everything.**
 
-6. **On Moltbook, write as an agent.** Use "my human" not "I". First-person agent perspective.
+### Anti-AI-Detection (applies to ALL content)
 
-7. **Log everything.** Every thread and comment goes in the database.
+8. **No em dashes (—).** Use commas, periods, or regular dashes (-) instead. Em dashes are the #1 "ChatGPT tell."
+9. **No markdown formatting in Reddit.** No headers (##), no bold (**text**), no numbered lists. Write in plain paragraphs.
+10. **Never cross-post.** One post per topic per community.
+11. **Space posts out.** Max 1 original post per day, max 3 per week. Don't spam.
+12. **Include imperfections.** Contractions, sentence fragments, casual asides, occasional lowercase.
+13. **Vary your openings.** Don't always start with credentials. Sometimes just jump into the topic.
+14. **Reply to comments on your posts.** Zero engagement on your own post = bot signal. Reply within 24h.
 
-### Bad vs Good
+### Bad vs Good (Comments)
 
-BAD: "Makes sense — Claude already tries to `| tail -n 50` on its own but by then the tokens are already in context."
-GOOD: "gonna try this — I run 5 agents in parallel and my API bill is becoming a second rent payment"
+BAD: "Makes sense — Claude already tries to tail the output on its own but by then the tokens are already in context."
+GOOD: "gonna try this, I run 5 agents in parallel and my API bill is becoming a second rent payment"
 
 BAD: "What everyone here is describing is basically specification-driven development."
 GOOD: "I spend more time writing CLAUDE.md specs than I ever spent writing code. the irony is I'm basically doing waterfall now and shipping faster than ever."
 
----
-
-## Tiered Reply Strategy
-
-When replying to comments on our posts, escalate project mentions based on conversation context.
-
-**Tier 1 — Default (no link):** Genuine engagement. Expand the topic, ask follow-ups. Most replies.
+### Bad vs Good (Original Posts)
 
-**Tier 2 — Natural mention:** Conversation touches something you're building. Mention the project casually. Include link only if it adds value. Triggers:
-- "what are you working on" / "what tool do you use"
-- They describe a problem matching a project's `topics` from `config.json`
-- Conversation is 2+ replies deep (genuine interest)
+BAD title: "What I Wish I'd Known Before My First Vipassana Retreat: A Complete Guide"
+GOOD title: "just did my 7th course, some things that surprised me"
 
-**Tier 3 — Direct ask:** They explicitly ask for a link, to try it, if it's open source. Give it immediately.
+BAD body: Structured with headers, bold, numbered lists, "As a tech founder..."
+GOOD body: Paragraphs, incomplete thoughts, personal details, casual tone, ends with a genuine question
 
 ---
 
-## Database Schema
+## Tiered Reply Strategy
 
-```sql
--- Core tables (see schema.sql for full DDL)
-posts        -- everything we post (platform, urls, content, engagement, status)
-threads      -- threads we've discovered
-our_posts    -- backward-compat post tracking
-replies      -- replies to our posts and our responses
-```
+**Tier 1 — Default (no link):** Genuine engagement. Expand topic, ask follow-ups. Most replies.
 
-Key fields in `posts`: `id, platform, thread_url, thread_title, our_url, our_content, our_account, posted_at, status, upvotes, comments_count, views, source_summary`
+**Tier 2 — Natural mention:** Conversation touches a topic matching one of the user's projects (from `config.json → projects[].topics`). Mention casually, link only if it adds value. Triggers: "what tool do you use", problem matches a project topic, 2+ replies deep.
 
-Key fields in `replies`: `id, post_id, platform, their_author, their_content, our_reply_content, status (pending|replied|skipped|error), depth`
+**Tier 3 — Direct ask:** They ask for link/try/source. Give it immediately using `projects[].website` or `projects[].github` from config.json.
 
 ---
 
-## Platform Reference
-
-**Reddit:** Use `old.reddit.com` for reliable automation. Comment box: textarea with class `usertext-edit`. No posting API — browser only.
-
-**X/Twitter:** Reply to existing tweets. 1-2 sentences ideal. No public API for notifications — browser only.
+## Database Schema
 
-**LinkedIn:** Professional tone, brief. Comments don't have stable URLs. Browser only.
+`posts`: id, platform, thread_url, thread_title, our_url, our_content, our_account, posted_at, status, upvotes, comments_count, views, source_summary
 
-**Moltbook:** Full REST API, no browser needed. Base: `https://www.moltbook.com/api/v1`. Auth: `Bearer $MOLTBOOK_API_KEY`. Agent-first platform — write as an agent.
+`replies`: id, post_id, platform, their_author, their_content, our_reply_content, status (pending|replied|skipped|error), depth

package/bin/cli.js

@@ -22,7 +22,7 @@ const COPY_TARGETS = [
 ];
 
 // Never overwrite these user files during update
-const USER_FILES = new Set(['config.json', '.env']);
+const USER_FILES = new Set(['config.json', '.env', 'SKILL.md']);
 
 function copyDir(src, dest) {
   fs.mkdirSync(dest, { recursive: true });
@@ -170,11 +170,15 @@ function init() {
     console.log('  psycopg2-binary already installed');
   }
 
-  // Skill symlinks
+  // Remove stale skill/SKILL.md if it exists (SKILL.md lives at repo root only)
+  const skillMd = path.join(DEST, 'skill', 'SKILL.md');
+  try { fs.rmSync(skillMd, { force: true }); } catch {}
+
+  // Skill symlinks — point to repo root so Claude loads SKILL.md directly
   const skillsDir = path.join(os.homedir(), '.claude', 'skills');
   fs.mkdirSync(skillsDir, { recursive: true });
-  linkOrRelink(path.join(DEST, 'skill'), path.join(skillsDir, 'social-autoposter'));
-  console.log('  ~/.claude/skills/social-autoposter ->', path.join(DEST, 'skill'));
+  linkOrRelink(DEST, path.join(skillsDir, 'social-autoposter'));
+  console.log('  ~/.claude/skills/social-autoposter ->', DEST);
   linkOrRelink(path.join(DEST, 'setup'), path.join(skillsDir, 'social-autoposter-setup'));
   console.log('  ~/.claude/skills/social-autoposter-setup ->', path.join(DEST, 'setup'));
 
@@ -214,10 +218,14 @@ function update() {
   // Regenerate launchd plists with correct paths
   generatePlists();
 
-  // Re-symlink skill and setup skill in case they broke
+  // Remove stale skill/SKILL.md if it exists (SKILL.md lives at repo root only)
+  const skillMd = path.join(DEST, 'skill', 'SKILL.md');
+  try { fs.rmSync(skillMd, { force: true }); } catch {}
+
+  // Re-symlink skills — point to repo root so Claude loads SKILL.md directly
   const skillsDir = path.join(os.homedir(), '.claude', 'skills');
   try {
-    linkOrRelink(path.join(DEST, 'skill'), path.join(skillsDir, 'social-autoposter'));
+    linkOrRelink(DEST, path.join(skillsDir, 'social-autoposter'));
     console.log('  re-linked ~/.claude/skills/social-autoposter');
   } catch {}
   try {
@@ -234,10 +242,13 @@ if (cmd === 'init') {
   init();
 } else if (cmd === 'update') {
   update();
+} else if (!cmd) {
+  require('./server.js');
 } else {
   console.log('social-autoposter — automated social posting for Claude agents');
   console.log('');
   console.log('Usage:');
-  console.log('  npx social-autoposter init    first-time setup');
-  console.log('  npx social-autoposter update  update scripts, preserve config');
+  console.log('  npx social-autoposter          open the dashboard');
+  console.log('  npx social-autoposter init      first-time setup');
+  console.log('  npx social-autoposter update    update scripts, preserve config');
 }