social-autoposter 1.0.0

package/README.md

@@ -0,0 +1,85 @@
+# social-autoposter
+
+Automated social posting pipeline for Reddit, X/Twitter, LinkedIn, and Moltbook. Install as an AI agent skill or use the standalone Python scripts.
+
+[**Browse the data in Datasette Lite**](https://lite.datasette.io/?url=https://raw.githubusercontent.com/m13v/social-autoposter/main/social_posts.db)
+
+## Install as a skill
+
+```bash
+npx social-autoposter init
+```
+
+Then tell your agent: **"set up social autoposter"** — the setup skill walks you through config, DB creation, browser logins, and a test run.
+
+To update scripts without touching your config or database:
+```bash
+npx social-autoposter update
+```
+
+Or set up manually:
+```bash
+cp config.example.json config.json   # edit with your accounts
+sqlite3 social_posts.db < schema.sql # create the database
+bash setup.sh                        # symlinks + launchd (macOS)
+```
+
+## How it works
+
+```
+SKILL.md (the playbook)
+    │
+    ├── /social-autoposter        → find thread, draft, post, log
+    ├── /social-autoposter stats  → update engagement via API
+    ├── /social-autoposter engage → scan replies, respond
+    └── /social-autoposter audit  → browser-based full audit
+    │
+    ├── scripts/find_threads.py   → thread discovery (no browser)
+    ├── scripts/scan_replies.py   → reply scanning (no browser)
+    └── scripts/update_stats.py   → stats fetching (no browser)
+    │
+    ├── skill/run.sh              → launchd wrapper (hourly)
+    ├── skill/stats.sh            → launchd wrapper (6-hourly)
+    └── skill/engage.sh           → launchd wrapper (2-hourly)
+```
+
+## Structure
+
+```
+social-autoposter/
+├── SKILL.md               <- skill playbook (generic, publishable)
+├── config.example.json    <- config template (accounts, subreddits, content angle)
+├── schema.sql             <- DB schema
+├── setup.sh               <- creates symlinks, loads launchd agents
+├── setup/
+│   └── SKILL.md           <- interactive setup wizard skill
+├── scripts/
+│   ├── find_threads.py    <- find candidate threads via Reddit/Moltbook API
+│   ├── scan_replies.py    <- scan for new replies to our posts via API
+│   └── update_stats.py    <- fetch engagement stats via API
+├── skill/
+│   ├── SKILL.md           <- personal skill (hardcoded accounts)
+│   ├── run.sh             <- hourly posting (launchd wrapper)
+│   ├── stats.sh           <- 6-hourly stats (launchd wrapper)
+│   ├── engage.sh          <- 2-hourly engagement (launchd wrapper)
+│   └── logs/              <- runtime logs (gitignored)
+├── social_posts.db        <- SQLite database (committed for Datasette)
+├── syncfield.sh           <- sync SQLite -> Neon Postgres
+└── launchd/               <- macOS LaunchAgent plists
+```
+
+## For other AI agents
+
+The skill is designed to work with any agent that has:
+- **Shell access** (to run Python scripts and sqlite3)
+- **Browser automation** (Playwright, Selenium, etc. for posting)
+- **An LLM** (for drafting comments in the right tone)
+
+The Python scripts handle thread discovery, reply scanning, and stats updates without needing a browser or LLM. The SKILL.md is the playbook — any agent reads it and executes the workflows with its own tools.
+
+## Accounts
+
+- **Reddit**: u/Deep_Ad1959
+- **X/Twitter**: @m13v_
+- **LinkedIn**: Matthew Diakonov
+- **Moltbook**: matthew-autoposter

package/SKILL.md

@@ -0,0 +1,317 @@
+---
+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."
+user_invocable: true
+---
+
+# Social Autoposter
+
+Automates finding, posting, and tracking social media comments. Works with any agent that has browser automation and shell access.
+
+## Quick Start
+
+| Command | What it does |
+|---------|-------------|
+| `/social-autoposter` | Full posting run (find threads + post + log) |
+| `/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
+
+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` — path to SQLite DB
+
+## Helper Scripts
+
+Standalone Python scripts any agent can call directly. No LLM needed for these.
+
+| 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 |
+
+Examples:
+```bash
+python3 scripts/find_threads.py --topic "macOS automation" --limit 5
+python3 scripts/scan_replies.py
+python3 scripts/update_stats.py --quiet
+```
+
+---
+
+## Critical: No Parallel Posting
+
+**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.
+
+**After each post, always verify** by reloading the page and confirming the comment appears exactly once before moving to the next post.
+
+---
+
+## Workflow: Post (`/social-autoposter`)
+
+Find a thread, draft a comment, post it, log it.
+
+### 1. Rate limit check
+
+```sql
+SELECT COUNT(*) FROM posts WHERE posted_at >= datetime('now', '-24 hours')
+```
+If 40+ posts in the last 24 hours, stop. Max 40/day.
+
+### 2. Find candidate threads
+
+**Option A — Use the helper script (preferred, no browser needed):**
+```bash
+python3 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.
+
+### 3. 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:
+  ```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.
+
+### 4. Read the thread
+
+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)
+
+### 5. 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
+
+### 6. 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
+
+**X/Twitter** (browser automation):
+- Navigate to the tweet
+- Type reply in the reply box, click Reply
+- Verify the reply posted
+- Capture the URL
+
+**LinkedIn** (browser automation):
+- Navigate to the post
+- Type comment, click Post
+- No stable URL available, note as posted
+
+**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" \
+  -d '{"title": "...", "content": "...", "type": "text", "submolt_name": "general"}' \
+  "https://www.moltbook.com/api/v1/posts"
+```
+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
+
+```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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'active', datetime('now'));
+```
+
+### 8. Sync (if configured)
+
+If `sync_script` is set in `config.json`, run it to push data to a remote database.
+
+---
+
+## Workflow: Stats (`/social-autoposter stats`)
+
+Update engagement metrics for all posts. No browser needed.
+
+**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
+```
+
+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.
+
+Updates `upvotes`, `comments_count`, `thread_engagement`, `engagement_updated_at` in the DB.
+
+For **X/Twitter** stats (requires browser): use `/social-autoposter audit` instead.
+
+---
+
+## Workflow: Engage (`/social-autoposter engage`)
+
+Discover replies to our posts and respond to them.
+
+### Phase A: Scan for replies (no browser needed)
+
+```bash
+python3 scripts/scan_replies.py
+```
+
+This scans Reddit JSON API + Moltbook API for new replies. Inserts into `replies` table as `pending` or `skipped`.
+
+Skip reasons: `too_short` (<5 words), `filtered_author` (AutoModerator, [deleted], self), `too_old` (>7 days), `deleted`.
+
+### Phase B: Respond to pending replies (needs browser/API)
+
+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
+```
+
+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=?, our_reply_url=?,
+     replied_at=datetime('now') WHERE id=?
+   ```
+
+Max 5 replies per run.
+
+### 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
+
+---
+
+## 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.
+
+---
+
+## 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.
+
+5. **No product links in top-level comments.** Earn attention first. Links come later via the Tiered Reply Strategy.
+
+6. **On Moltbook, write as an agent.** Use "my human" not "I". First-person agent perspective.
+
+7. **Log everything.** Every thread and comment goes in the database.
+
+### Bad vs Good
+
+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: "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.
+
+**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)
+
+**Tier 3 — Direct ask:** They explicitly ask for a link, to try it, if it's open source. Give it immediately.
+
+---
+
+## Database Schema
+
+```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
+```
+
+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`
+
+Key fields in `replies`: `id, post_id, platform, their_author, their_content, our_reply_content, status (pending|replied|skipped|error), depth`
+
+---
+
+## 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.
+
+**LinkedIn:** Professional tone, brief. Comments don't have stable URLs. Browser only.
+
+**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.

package/bin/cli.js

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const { spawnSync } = require('child_process');
+
+const DEST = path.join(os.homedir(), 'social-autoposter');
+const PKG_ROOT = path.join(__dirname, '..');
+
+// Files/dirs to copy from npm package to ~/social-autoposter
+const COPY_TARGETS = [
+  'scripts',
+  'schema.sql',
+  'config.example.json',
+  'SKILL.md',
+  'skill',
+  'setup',
+  'launchd',
+  'syncfield.sh',
+];
+
+// Never overwrite these user files during update
+const USER_FILES = new Set(['config.json', 'social_posts.db', '.env']);
+
+function copyDir(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+function linkOrRelink(target, linkPath) {
+  try { fs.rmSync(linkPath, { recursive: true, force: true }); } catch {}
+  fs.symlinkSync(target, linkPath);
+}
+
+function init() {
+  console.log('Setting up social-autoposter in', DEST);
+  fs.mkdirSync(DEST, { recursive: true });
+
+  // Copy all package files
+  for (const f of COPY_TARGETS) {
+    const src = path.join(PKG_ROOT, f);
+    const dest = path.join(DEST, f);
+    if (!fs.existsSync(src)) continue;
+    const stat = fs.statSync(src);
+    if (stat.isDirectory()) {
+      copyDir(src, dest);
+    } else {
+      fs.copyFileSync(src, dest);
+    }
+    console.log('  copied', f);
+  }
+
+  // config.json — only if it doesn't exist
+  const configDest = path.join(DEST, 'config.json');
+  if (!fs.existsSync(configDest)) {
+    fs.copyFileSync(path.join(PKG_ROOT, 'config.example.json'), configDest);
+    console.log('  created config.json from template');
+  } else {
+    console.log('  config.json exists — skipping');
+  }
+
+  // Create DB from schema if missing
+  const dbPath = path.join(DEST, 'social_posts.db');
+  if (!fs.existsSync(dbPath)) {
+    const schemaPath = path.join(DEST, 'schema.sql');
+    const result = spawnSync('sqlite3', [dbPath], {
+      input: fs.readFileSync(schemaPath),
+      stdio: ['pipe', 'inherit', 'inherit'],
+    });
+    if (result.status === 0) {
+      console.log('  created social_posts.db');
+    } else {
+      console.warn('  WARNING: sqlite3 failed — create DB manually:');
+      console.warn('    sqlite3 ~/social-autoposter/social_posts.db < ~/social-autoposter/schema.sql');
+    }
+  } else {
+    console.log('  social_posts.db exists — skipping');
+  }
+
+  // Skill symlink: ~/.claude/skills/social-autoposter -> ~/social-autoposter/skill
+  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'));
+
+  // DB symlink: ~/.claude/social_posts.db -> ~/social-autoposter/social_posts.db
+  const claudeDir = path.join(os.homedir(), '.claude');
+  try {
+    linkOrRelink(dbPath, path.join(claudeDir, 'social_posts.db'));
+    console.log('  ~/.claude/social_posts.db ->', dbPath);
+  } catch {}
+
+  console.log('');
+  console.log('Done! Next steps:');
+  console.log('  1. Edit ~/social-autoposter/config.json with your accounts');
+  console.log('  2. Tell your Claude agent: "set up social autoposter"');
+  console.log('     (uses the setup/SKILL.md wizard for browser login verification)');
+  console.log('  3. Or configure manually and run: bash ~/social-autoposter/setup.sh');
+}
+
+function update() {
+  if (!fs.existsSync(DEST)) {
+    console.error('Not installed. Run: npx social-autoposter init');
+    process.exit(1);
+  }
+
+  console.log('Updating social-autoposter...');
+
+  for (const f of COPY_TARGETS) {
+    if (USER_FILES.has(f)) {
+      console.log('  skipping', f, '(user file)');
+      continue;
+    }
+    const src = path.join(PKG_ROOT, f);
+    const dest = path.join(DEST, f);
+    if (!fs.existsSync(src)) continue;
+    const stat = fs.statSync(src);
+    if (stat.isDirectory()) {
+      copyDir(src, dest);
+    } else {
+      fs.copyFileSync(src, dest);
+    }
+    console.log('  updated', f);
+  }
+
+  // Re-symlink skill in case it broke
+  const skillsDir = path.join(os.homedir(), '.claude', 'skills');
+  try {
+    linkOrRelink(path.join(DEST, 'skill'), path.join(skillsDir, 'social-autoposter'));
+    console.log('  re-linked ~/.claude/skills/social-autoposter');
+  } catch {}
+
+  console.log('');
+  console.log('Update complete. config.json and social_posts.db were preserved.');
+}
+
+const cmd = process.argv[2];
+if (cmd === 'init') {
+  init();
+} else if (cmd === 'update') {
+  update();
+} 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');
+}

package/config.example.json

@@ -0,0 +1,51 @@
+{
+  "database": "~/social-autoposter/social_posts.db",
+  "prompt_db": "~/claude-prompt-db/prompts.db",
+  "sync_script": "~/social-autoposter/syncfield.sh",
+  "stats_script": "~/.claude/skills/social-autoposter/stats.sh",
+
+  "accounts": {
+    "reddit": {
+      "username": "your-reddit-username",
+      "login_method": "browser"
+    },
+    "twitter": {
+      "handle": "@your-twitter-handle",
+      "login_method": "browser"
+    },
+    "linkedin": {
+      "name": "Your Name",
+      "login_method": "browser"
+    },
+    "moltbook": {
+      "username": "your-moltbook-username",
+      "api_key_env": "MOLTBOOK_API_KEY",
+      "env_file": "~/social-autoposter/.env"
+    }
+  },
+
+  "subreddits": ["ClaudeAI", "programming", "webdev", "devops"],
+
+  "content_angle": "Describe your unique experience/perspective that gives you authentic angles for comments. Example: 'Building a macOS desktop AI agent. Experience with Swift, browser automation, MCP tools, and running 5 Claude agents in parallel.'",
+
+  "projects": [
+    {
+      "name": "My Main Project",
+      "description": "One-line description of what it does",
+      "website": "https://example.com",
+      "github": "",
+      "topics": ["desktop automation", "AI agents", "browser control"],
+      "_comment": "Topics are keywords that trigger mentioning this project in replies. When a conversation touches these topics, the tiered reply strategy may naturally mention this project."
+    },
+    {
+      "name": "My Open Source Tool",
+      "description": "What the tool does",
+      "website": "",
+      "github": "https://github.com/you/your-repo",
+      "topics": ["macOS automation", "accessibility APIs"]
+    }
+  ],
+
+  "open_source_links": [],
+  "launchd_label": "com.yourname.social-stats"
+}

package/launchd/com.m13v.social-autoposter.plist

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>Label</key>
+	<string>com.m13v.social-autoposter</string>
+	<key>ProgramArguments</key>
+	<array>
+		<string>/bin/bash</string>
+		<string>/Users/matthewdi/.claude/skills/social-autoposter/skill/run.sh</string>
+	</array>
+	<key>StartInterval</key>
+	<integer>3600</integer>
+	<key>StandardOutPath</key>
+	<string>/Users/matthewdi/.claude/skills/social-autoposter/logs/launchd-stdout.log</string>
+	<key>StandardErrorPath</key>
+	<string>/Users/matthewdi/.claude/skills/social-autoposter/logs/launchd-stderr.log</string>
+	<key>EnvironmentVariables</key>
+	<dict>
+		<key>PATH</key>
+		<string>/Users/matthewdi/.nvm/versions/node/v20.19.4/bin:/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin</string>
+		<key>HOME</key>
+		<string>/Users/matthewdi</string>
+	</dict>
+	<key>RunAtLoad</key>
+	<true/>
+</dict>
+</plist>

package/launchd/com.m13v.social-engage.plist

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>Label</key>
+	<string>com.m13v.social-engage</string>
+	<key>ProgramArguments</key>
+	<array>
+		<string>/bin/bash</string>
+		<string>/Users/matthewdi/.claude/skills/social-autoposter/skill/engage.sh</string>
+	</array>
+	<key>StartInterval</key>
+	<integer>21600</integer>
+	<key>StandardOutPath</key>
+	<string>/Users/matthewdi/.claude/skills/social-autoposter/logs/launchd-engage-stdout.log</string>
+	<key>StandardErrorPath</key>
+	<string>/Users/matthewdi/.claude/skills/social-autoposter/logs/launchd-engage-stderr.log</string>
+	<key>EnvironmentVariables</key>
+	<dict>
+		<key>PATH</key>
+		<string>/Users/matthewdi/.nvm/versions/node/v20.19.4/bin:/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin</string>
+		<key>HOME</key>
+		<string>/Users/matthewdi</string>
+	</dict>
+	<key>RunAtLoad</key>
+	<false/>
+</dict>
+</plist>