@m13v/s4l 1.7.5-rc.3 → 1.7.5-rc.30

package/mcp/dist/index.js

@@ -20,8 +20,9 @@ import os from "node:os";
 import path from "node:path";
 import fs from "node:fs";
 import { repoDir, runPython, run, readPlan, writePlan, planPath, } from "./repo.js";
-import { applySetup, resolveProject, hasReadyProject, personaReady, listManagedProjectStatus, listProjectSettings, ensureShortLinksDefault, ensurePersonaProject, findPersonaProject, REQUIRED_FIELDS, RECOMMENDED_FIELDS, configPath, normalizeStringList, } from "./setup.js";
+import { applySetup, resolveProject, hasReadyProject, personaReady, listManagedProjectStatus, listProjectSettings, ensureShortLinksDefault, ensurePersonaProject, findPersonaProject, REQUIRED_FIELDS, RECOMMENDED_FIELDS, configPath, ensureConfigInStateDir, normalizeStringList, recordRedditAccount, } from "./setup.js";
 import { xStatus, xConnect, xDetectSources, xScanProfile, summarizeXAuth } from "./twitterAuth.js";
+import { redditStatus, redditConnect, redditDetectSources, summarizeRedditAuth, } from "./redditAuth.js";
 import { startProvisioning, isProvisioning, readProgress, runtimeReady, readRuntime, resolvePython, resolveChrome, ensureMenubar, menubarRunning, clearMenubarStop, ensurePipelineCurrent, ensureRuntimeProvisioned, ensureHarnessPatched, retryProvisionIfStalled, } from "./runtime.js";
 import { blockOnboardingMilestone, completeOnboardingMilestone, ensureDoctorPhase, onboardingLedger, onboardingSnapshot, recordOnboardingAttempt, runDoctorPhase, } from "./onboarding.js";
 import { VERSION, versionStatus, latestPublishedVersion } from "./version.js";
@@ -68,6 +69,17 @@ const PHASE1_TASK_ID = "saps-phase1-query"; // legacy (was: "twitter-query" only
 const PHASE2B_TASK_ID = "saps-phase2b-draft"; // legacy (was: "twitter-prep" only)
 const TWITTER_AUTOPILOT_LABEL = "com.m13v.social-twitter-cycle";
 const TWITTER_AUTOPILOT_PLIST = path.join(os.homedir(), "Library", "LaunchAgents", `${TWITTER_AUTOPILOT_LABEL}.plist`);
+// Reddit discovery kicker (optional platform, 2026-07-15). Runs the SAME
+// launchd label the operator Mac has used by hand since May
+// (com.m13v.social-reddit-search) so there is one canonical name fleet-wide,
+// but ensureRedditKickerInstalled() refuses to touch a plist whose program
+// path points outside the managed package (the operator's hand-built plist
+// stays untouched). Installed only when reddit is connected AND a project is
+// configured; never part of onboarding completion.
+const REDDIT_SEARCH_LABEL = "com.m13v.social-reddit-search";
+const REDDIT_SEARCH_PLIST = path.join(os.homedir(), "Library", "LaunchAgents", `${REDDIT_SEARCH_LABEL}.plist`);
+const REDDIT_SEARCH_INTERVAL_SECS = 900;
+const REDDIT_CDP_URL_DEFAULT = "http://127.0.0.1:9557";
 // Self-healing reaper for leaked Claude agent-mode worker sessions. The queue
 // autopilot fires two scheduled tasks every ~1 min; each fire spawns a ~200 MB
 // `claude` agent-mode session that finishes its one queue turn but never exits
@@ -313,7 +325,9 @@ const server = new McpServer({
         "can run them hands-free on autopilot.\n\n" +
         "ONBOARDING IS A TERMINAL GOAL. When the user asks to set up, install, configure, or onboard " +
         "social-autoposter, keep taking the next safe action until the owned runtime is ready, a " +
-        "project is fully configured with seeded search topics, X is connected with its real handle, AND " +
+        "project is fully configured with seeded search topics, AT LEAST ONE platform is connected " +
+        "(X with its real handle is the DEFAULT first suggestion; Reddit via connect_reddit counts " +
+        "equally if the user prefers it or X connection fails or is skipped), AND " +
         "the two draft-autopilot scheduled tasks have been created via queue_setup and are firing " +
         "(see SCHEDULE THE AUTOPILOT below). The owned runtime (private Python + Chromium) provisions " +
         "ITSELF automatically on boot — you do NOT install it. Just poll runtime action:'status' until it " +
@@ -329,7 +343,8 @@ const server = new McpServer({
         "or pause for an unavoidable interactive login or OS prompt. Never auto-POST during setup. " +
         "DO schedule the draft autopilot as the final step (once running it only queues drafts for " +
         "approval, it never posts on its own). When setup reaches done (" +
-        "runtime ready, a project configured with seeded topics, X connected, and the two scheduled tasks " +
+        "runtime ready, a project configured with seeded topics, at least one platform connected, and the " +
+        "two scheduled tasks " +
         "created and firing), call the `dashboard` tool so the user " +
         "sees the finished setup rendered, then give " +
         "the completion summary.\n\n" +
@@ -351,6 +366,16 @@ const server = new McpServer({
         "old 'social-autoposter-autopilot' task — it is deprecated. Do NOT ask the user to review drafts " +
         "or pause for input mid-onboarding; once the tasks are created and firing, setup is done. If the " +
         "host exposes no create_scheduled_task tool, tell the user the autopilot couldn't be scheduled here.\n\n" +
+        "REDDIT IS AN EQUAL, OPTIONAL PLATFORM. Setup is complete with AT LEAST ONE platform " +
+        "connected: X-only, Reddit-only, or both. X stays the default first suggestion; offer Reddit " +
+        "as an add-on after X setup completes, OR standalone when the user prefers Reddit or X " +
+        "connection fails or is skipped. `project_config` action:'connect_reddit' imports the user's " +
+        "reddit.com session into the autoposter's managed reddit browser, same confirm-first flow and " +
+        "keychain heads-up as connect_x. Once connected, reddit discovery and drafting run on the same " +
+        "draft-only queue and review cards as X; nothing posts without approval. If the result carries " +
+        "a `warning` (fresh or low-karma account), relay it so the user knows AutoMod may gate early " +
+        "replies. Never make Reddit a requirement, and never nag a happily X-only (or reddit-only) " +
+        "user about the other platform.\n\n" +
         "BE PROACTIVE ABOUT MARKETING MOMENTS. Whenever the user ships, finishes, merges, or releases " +
         "something worth talking about in this session (a new feature, a launch, a long-awaited fix, a " +
         "milestone), don't wait to be asked: point it out to the user — the draft autopilot runs " +
@@ -827,7 +852,7 @@ function readConfiguredTwitterHandle() {
     if (env)
         return env;
     try {
-        const cfg = JSON.parse(fs.readFileSync(path.join(repoDir(), "config.json"), "utf-8"));
+        const cfg = JSON.parse(fs.readFileSync(configPath(), "utf-8"));
         const h = cfg?.accounts?.twitter?.handle;
         const s = (typeof h === "string" ? h : "").trim().replace(/^@/, "");
         return s || null;
@@ -885,6 +910,57 @@ function expiredStampOverridable(c) {
         c.posted !== true &&
         c.discard_reason === "backend_status_expired");
 }
+function mergeApprovedStampsIntoStore(batchId, plan, stamped) {
+    // Merge posted/terminal stamps into a FRESH read of the store instead of
+    // rewriting the whole plan from the copy taken minutes ago. The old
+    // whole-file write was last-writer-wins: while a batch posted, the menubar
+    // (decision re-stamps) and any peer drain also wrote the store, and
+    // whichever run finished last erased the others' posted flags (2026-07-06:
+    // card 344877 posted at 00:29Z ended `posted=None,
+    // terminal=duplicate_thread_pre_post` after a later run's stale write).
+    // Merge rules: `posted` is sticky and wins over terminal; `terminal` never
+    // overwrites a fresh `posted=true`. Fallback: candidates without a
+    // candidate_id can't be matched into the fresh copy, so keep the legacy
+    // whole-plan write for those older plans.
+    try {
+        const mergeable = stamped.every((c) => c.candidate_id !== undefined && c.candidate_id !== null);
+        const fresh = mergeable ? readPlan(batchId) : null;
+        if (fresh && Array.isArray(fresh.candidates)) {
+            const freshById = new Map();
+            fresh.candidates.forEach((c) => {
+                if (c.candidate_id !== undefined && c.candidate_id !== null)
+                    freshById.set(String(c.candidate_id), c);
+            });
+            for (const c of stamped) {
+                const f = freshById.get(String(c.candidate_id));
+                if (!f)
+                    continue;
+                if (c.posted === true) {
+                    f.posted = true;
+                    f.terminal = false;
+                    if (c.our_url)
+                        f.our_url = c.our_url;
+                }
+                else if (c.terminal === true && f.posted !== true) {
+                    f.terminal = true;
+                    f.terminal_reason = c.terminal_reason;
+                }
+            }
+            writePlan(batchId, fresh);
+        }
+        else {
+            writePlan(batchId, plan);
+        }
+    }
+    catch {
+        try {
+            writePlan(batchId, plan);
+        }
+        catch {
+            /* best effort */
+        }
+    }
+}
 async function postApproved(batchId, plan) {
     // Drain serialization (2026-07-06 incident). Every call drains the WHOLE
     // approved backlog, so overlapping drains are pure waste and actively harmful:
@@ -951,6 +1027,181 @@ async function postApproved(batchId, plan) {
     }
     if (approved.length === 0)
         return { attempted: 0, exit_code: 0, summary: "nothing approved" };
+    // ---- Reddit cards (2026-07-14): drain them FIRST, independently ----------
+    // A reddit card carries the verbatim draft decision (reddit_decision) plus
+    // plan metadata (reddit_plan_meta), so approval reconstructs a one-decision
+    // plan and reuses `post_reddit.py --phase post` unchanged — per-row
+    // reddit-browser lease, URL wrapping, campaign suffixes, and log_post all
+    // stay in the one battle-tested poster. The twitter handle preflight and
+    // twitter-browser lock ceremony below are twitter-only, so reddit must not
+    // be gated on them (and an all-reddit batch returns before any of it).
+    const approvedReddit = approved.filter((c) => c.platform === "reddit");
+    const approvedTwitter = approved.filter((c) => c.platform !== "reddit");
+    let redditPosted = 0;
+    let redditFailed = 0;
+    let redditSkippedPeerDrain = false;
+    if (approvedReddit.length) {
+        // Cross-instance drain gate (2026-07-14 drain storm): every one-shot MCP
+        // boot (the queue worker fires ~every minute; each boot runs the startup
+        // backlog drain) drained the SAME sticky approvals concurrently — 26
+        // drain plans in ~30 minutes, all fighting over the one reddit tab and
+        // false-positiving each other's posts. reddit-posting-active.json is the
+        // arbiter: post_reddit.py heartbeats it per row, and we stamp it around
+        // the whole drain here. A fresh flag (<120s) means a peer is mid-drain:
+        // leave the cards for it — approvals are sticky, nothing is lost.
+        const redditFlagPath = path.join(s4lStateDir(), "reddit-posting-active.json");
+        let redditPeerFresh = false;
+        try {
+            redditPeerFresh = Date.now() - fs.statSync(redditFlagPath).mtimeMs < 120_000;
+        }
+        catch {
+            redditPeerFresh = false;
+        }
+        const stampRedditFlag = () => {
+            try {
+                fs.writeFileSync(redditFlagPath, JSON.stringify({ pid: process.pid, hb: Math.floor(Date.now() / 1000) }));
+            }
+            catch {
+                /* best effort */
+            }
+        };
+        if (redditPeerFresh) {
+            redditSkippedPeerDrain = true;
+            logPostEvent(`postApproved_reddit_skip batch=${batchId} reason=peer_drain_active cards=${approvedReddit.length}`);
+        }
+        else {
+            stampRedditFlag();
+            try {
+                for (const c of approvedReddit) {
+                    stampRedditFlag();
+                    const cc = c;
+                    const dec = cc.reddit_decision;
+                    const meta = (cc.reddit_plan_meta || {});
+                    if (!dec) {
+                        c.terminal = true;
+                        c.terminal_reason = "reddit_decision_missing";
+                        redditFailed++;
+                        continue;
+                    }
+                    // The card's reply_text is the CANONICAL text (post_drafts edits write
+                    // there); the embedded decision still carries the draft-time original.
+                    // Posting dec.text verbatim would silently discard a human edit.
+                    const decPost = {
+                        ...dec,
+                        text: (typeof cc.reply_text === "string" && cc.reply_text.trim())
+                            ? cc.reply_text
+                            : dec.text,
+                    };
+                    if (cc.engagement_style)
+                        decPost.engagement_style = cc.engagement_style;
+                    // Two-draft cards (2026-07-15): a human draft-switch (see the generic
+                    // edit-handling above, `if (e.variant && Array.isArray(c.drafts))`)
+                    // stamps the CHOSEN draft's assigned_style/assigned_mode onto the card
+                    // (cc). Forward both into decPost so post_reddit.py's _post_iteration
+                    // validates/logs against whichever draft is ACTUALLY posting, not
+                    // whichever was recommended at plan-write time — mirrors
+                    // twitter_post_plan.py's identical per-candidate override.
+                    if (cc.assigned_style !== undefined)
+                        decPost.assigned_style = cc.assigned_style;
+                    if (cc.assigned_mode !== undefined)
+                        decPost.assigned_mode = cc.assigned_mode;
+                    const miniPlan = {
+                        project_name: meta.project_name || cc.matched_project,
+                        batch_id: cc.reddit_batch_id || meta.batch_id || "reddit-mcp-approval",
+                        phase: "draft",
+                        decisions: [decPost],
+                        style_assignment: meta.style_assignment || {},
+                        generation_trace_path: meta.generation_trace_path,
+                        session_id: meta.session_id || meta.draft_session_id,
+                    };
+                    const tmpPlan = path.join(process.env.S4L_TMP_DIR || "/tmp", `reddit_mcp_post_${Date.now()}_${Math.floor(Math.random() * 1e6)}.json`);
+                    let r;
+                    try {
+                        fs.writeFileSync(tmpPlan, JSON.stringify(miniPlan));
+                        r = await runPython("scripts/post_reddit.py", ["--phase", "post", "--in", tmpPlan], {
+                            timeoutMs: 900_000,
+                            env: {
+                                REDDIT_CDP_URL: process.env.REDDIT_CDP_URL || "http://127.0.0.1:9557",
+                                // Reviewed posts never get the active-campaign suffix (same rule
+                                // as the twitter manual-approval path below).
+                                S4L_SKIP_CAMPAIGN_SUFFIX: "1",
+                            },
+                            onLine: (line) => {
+                                const t = line.replace(/\s+$/, "");
+                                if (t.trim())
+                                    console.error(`[post-reddit] ${t}`);
+                            },
+                        });
+                    }
+                    catch (err) {
+                        r = { code: -1, stdout: "", stderr: String(err) };
+                    }
+                    finally {
+                        try {
+                            fs.unlinkSync(tmpPlan);
+                        }
+                        catch {
+                            /* best effort */
+                        }
+                    }
+                    // post_reddit.py's summary marker: `[post_reddit] phase=post ... posted=N failed=M`
+                    const out = `${r.stdout}\n${r.stderr}`;
+                    const postedN = Number((/posted=(\d+)/.exec(out) || [])[1] || 0);
+                    if (r.code === 0 && postedN > 0) {
+                        c.posted = true;
+                        c.terminal = false;
+                        const urlMatch = /(https:\/\/(?:old\.|www\.)?reddit\.com\/r\/\S+)/.exec((/\[post_reddit\][^\n]*posted[^\n]*/i.exec(out) || [""])[0]);
+                        if (urlMatch)
+                            c.our_url = urlMatch[1];
+                        redditPosted++;
+                    }
+                    else {
+                        // Leave the approval sticky (approved && !posted && !terminal) so the
+                        // next post_drafts call retries, mirroring twitter's failed-drain
+                        // semantics; only stamp terminal on a conclusive CDP refusal.
+                        const cdpReason = (/\[post_reddit\] CDP FAILED: ([a-z_]+)/.exec(out) || [])[1];
+                        if (cdpReason && ["thread_locked", "thread_archived", "thread_not_found", "blocked_by_author"].includes(cdpReason)) {
+                            c.terminal = true;
+                            c.terminal_reason = `reddit_${cdpReason}`;
+                        }
+                        redditFailed++;
+                    }
+                }
+            }
+            finally {
+                // Clear only OUR stamp; a peer that took over mid-drain keeps its own.
+                try {
+                    const cur = JSON.parse(fs.readFileSync(redditFlagPath, "utf-8"));
+                    if (cur && cur.pid === process.pid)
+                        fs.unlinkSync(redditFlagPath);
+                }
+                catch {
+                    /* best effort */
+                }
+            }
+            logPostEvent(`postApproved_reddit batch=${batchId} attempted=${approvedReddit.length} posted=${redditPosted} failed=${redditFailed}`);
+        }
+    }
+    if (approvedTwitter.length === 0) {
+        // All-reddit batch: persist the stamps and return without touching the
+        // twitter preflight/lock path.
+        if (redditSkippedPeerDrain) {
+            return {
+                attempted: 0,
+                posted: 0,
+                exit_code: 0,
+                summary: "reddit: skipped (peer drain active); cards stay approved for the next drain",
+            };
+        }
+        if (approvedReddit.length)
+            mergeApprovedStampsIntoStore(batchId, plan, approvedReddit);
+        return {
+            attempted: approvedReddit.length,
+            posted: redditPosted,
+            exit_code: redditFailed ? 1 : 0,
+            summary: `reddit: posted=${redditPosted} failed=${redditFailed}`,
+        };
+    }
     // PREFLIGHT: posting needs a configured @handle, or twitter_browser.py refuses
     // EVERY reply with no_account_configured and the whole batch skips — invisibly.
     // If onboarding never persisted it, self-heal from the live session; if even that
@@ -1002,7 +1253,7 @@ async function postApproved(batchId, plan) {
         };
     }
     const approvedBatch = `${batchId}_approved`;
-    writePlan(approvedBatch, { ...plan, candidates: approved });
+    writePlan(approvedBatch, { ...plan, candidates: approvedTwitter });
     // S4L_SKIP_CAMPAIGN_SUFFIX=1: manual/reviewed posts from this MCP draft_cycle
     // never get the active-campaign suffix (e.g. " written with ai") appended.
     // twitter_browser.py's reply handler reads this env (inherited through
@@ -1015,7 +1266,7 @@ async function postApproved(batchId, plan) {
                 const failure = {
                     posted: 0,
                     skipped: 0,
-                    failed: approved.length,
+                    failed: approvedTwitter.length,
                     failure_reasons: "browser_bootstrap_failed",
                     skip_reasons: "",
                 };
@@ -1031,7 +1282,7 @@ async function postApproved(batchId, plan) {
                 // (Karol 2026-07-09: 0/131 posted, exit=-1). 60s/card headroom covers
                 // slow candidates; the 2h cap bounds a hung poster (the browser-lock
                 // expiry and per-reply subprocess timeouts still fire underneath).
-                timeoutMs: Math.min(7_200_000, Math.max(900_000, approved.length * 60_000)),
+                timeoutMs: Math.min(7_200_000, Math.max(900_000, approvedTwitter.length * 60_000)),
                 env: ({
                     S4L_SKIP_CAMPAIGN_SUFFIX: "1",
                     // Manual approval is an EXCEPTION to the tail-link A/B. The cron pipeline
@@ -1098,7 +1349,7 @@ async function postApproved(batchId, plan) {
         const postLogDir = path.join(repoDir(), "skill", "logs");
         fs.mkdirSync(postLogDir, { recursive: true });
         const stamp = new Date().toISOString().replace(/[:.]/g, "-");
-        fs.writeFileSync(path.join(postLogDir, `post-${stamp}.log`), `# post_drafts batch=${batchId} approved=${approved.length} exit=${res.code} ` +
+        fs.writeFileSync(path.join(postLogDir, `post-${stamp}.log`), `# post_drafts batch=${batchId} approved=${approvedTwitter.length} exit=${res.code} ` +
             `shell_lock=${heldShellLock}\n\n=== stdout ===\n${res.stdout}\n\n=== stderr ===\n${res.stderr}\n`);
     }
     catch {
@@ -1121,7 +1372,7 @@ async function postApproved(batchId, plan) {
     const realPosted = summObj && typeof summObj.posted === "number"
         ? summObj.posted
         : res.code === 0 && !summObj
-            ? approved.length
+            ? approvedTwitter.length
             : 0;
     // Mark candidates according to the poster's per-candidate outcome. This keeps
     // the review queue honest: posted drafts disappear as posted, terminal skips
@@ -1142,14 +1393,14 @@ async function postApproved(batchId, plan) {
             .filter((r) => r.candidate_id && ["posted", "skipped", "failed"].includes(r.outcome))
         : parsePostCandidateResults(res.stdout);
     const approvedById = new Map();
-    approved.forEach((c) => {
+    approvedTwitter.forEach((c) => {
         if (c.candidate_id !== undefined && c.candidate_id !== null)
             approvedById.set(String(c.candidate_id), c);
     });
     let touchedPlan = false;
     if (resultRows.length) {
         resultRows.forEach((r, idx) => {
-            const c = approvedById.get(r.candidate_id) || approved[idx];
+            const c = approvedById.get(r.candidate_id) || approvedTwitter[idx];
             if (!c)
                 return;
             if (r.outcome === "posted") {
@@ -1169,59 +1420,14 @@ async function postApproved(batchId, plan) {
     else if (realPosted > 0 || (res.code === 0 && !summObj)) {
         // Legacy fallback for older poster output without parseable per-candidate
         // lines. Mark only when we have no finer-grained signal.
-        for (const c of approved)
+        for (const c of approvedTwitter)
             c.posted = true;
         touchedPlan = true;
     }
-    if (touchedPlan) {
-        try {
-            // Merge our stamps into a FRESH read of the store instead of rewriting the
-            // whole plan from the copy we took minutes ago. The old whole-file write
-            // was last-writer-wins: while this batch posted, the menubar (decision
-            // re-stamps) and any peer drain also wrote the store, and whichever run
-            // finished last erased the others' posted flags (2026-07-06: card 344877
-            // posted at 00:29Z ended `posted=None, terminal=duplicate_thread_pre_post`
-            // after a later run's stale write). Merge rules: `posted` is sticky and
-            // wins over terminal; `terminal` never overwrites a fresh `posted=true`.
-            // Fallback: candidates without a candidate_id can't be matched into the
-            // fresh copy, so keep the legacy whole-plan write for those older plans.
-            const mergeable = approved.every((c) => c.candidate_id !== undefined && c.candidate_id !== null);
-            const fresh = mergeable ? readPlan(batchId) : null;
-            if (fresh && Array.isArray(fresh.candidates)) {
-                const freshById = new Map();
-                fresh.candidates.forEach((c) => {
-                    if (c.candidate_id !== undefined && c.candidate_id !== null)
-                        freshById.set(String(c.candidate_id), c);
-                });
-                for (const c of approved) {
-                    const f = freshById.get(String(c.candidate_id));
-                    if (!f)
-                        continue;
-                    if (c.posted === true) {
-                        f.posted = true;
-                        f.terminal = false;
-                        if (c.our_url)
-                            f.our_url = c.our_url;
-                    }
-                    else if (c.terminal === true && f.posted !== true) {
-                        f.terminal = true;
-                        f.terminal_reason = c.terminal_reason;
-                    }
-                }
-                writePlan(batchId, fresh);
-            }
-            else {
-                writePlan(batchId, plan);
-            }
-        }
-        catch {
-            try {
-                writePlan(batchId, plan);
-            }
-            catch {
-                /* best effort */
-            }
-        }
+    // Reddit stamps (set in the reddit drain above) merge alongside the twitter
+    // ones: `approved` here spans both platforms.
+    if (touchedPlan || redditPosted || redditFailed) {
+        mergeApprovedStampsIntoStore(batchId, plan, approved);
     }
     // Post failures are HANDLED in the pipeline (it returns a count, never throws),
     // so they never reach Sentry on their own. Capture an explicit event whenever
@@ -1240,10 +1446,10 @@ async function postApproved(batchId, plan) {
     // actionable error on its own.
     const hasRealFailure = res.code !== 0 || Boolean(summObj?.failure_reasons);
     if (hasRealFailure) {
-        captureError(new Error(`post_drafts: ${realPosted}/${approved.length} posted (exit=${res.code})`), {
+        captureError(new Error(`post_drafts: ${realPosted}/${approvedTwitter.length} posted (exit=${res.code})`), {
             component: "post",
             exit_code: String(res.code),
-            attempted: String(approved.length),
+            attempted: String(approvedTwitter.length),
             posted: String(realPosted),
             failure_reasons: String(summObj?.failure_reasons || ""),
             skip_reasons: String(summObj?.skip_reasons || ""),
@@ -1254,9 +1460,11 @@ async function postApproved(batchId, plan) {
     void flushLogs();
     return {
         attempted: approved.length,
-        posted: realPosted,
+        posted: realPosted + redditPosted,
         exit_code: res.code,
-        summary,
+        summary: approvedReddit.length > 0
+            ? { twitter: summary, reddit: { posted: redditPosted, failed: redditFailed } }
+            : summary,
         stderr_tail: res.stderr.split("\n").slice(-8).join("\n"),
     };
 }
@@ -1761,7 +1969,14 @@ tool("project_config", {
     inputSchema: {
         status: z.boolean().optional(),
         action: z
-            .enum(["get", "connect_x", "detect_x_sources", "profile_scan"])
+            .enum([
+            "get",
+            "connect_x",
+            "detect_x_sources",
+            "profile_scan",
+            "connect_reddit",
+            "detect_reddit_sources",
+        ])
             .optional()
             .describe("get = read the CURRENT SAVED VALUES of every project's editable fields (website, " +
             "description, icp, voice, differentiator, search_topics, get_started_link, " +
@@ -1779,7 +1994,13 @@ tool("project_config", {
             "replies to build a 'grounding truth' corpus. Use it to draft voice/icp/search_topics in " +
             "the USER'S OWN register (their phrases, vibe, profession), then save a conservative best " +
             "draft without requiring a confirmation round-trip. Returns {profile, posts, comments, " +
-            "grounding_instructions}."),
+            "grounding_instructions}. " +
+            "connect_reddit = OPTIONAL equal platform (setup completes with X-only, Reddit-only, or " +
+            "both; offer Reddit after X setup, or standalone when the user prefers it or X fails/is " +
+            "skipped): import/validate the user's reddit.com session in the " +
+            "autoposter's managed reddit browser, same confirm-first shape as connect_x. " +
+            "detect_reddit_sources = list the browsers/profiles the Reddit session can be imported " +
+            "from (read-only, no keychain prompt)."),
         confirm: z
             .boolean()
             .optional()
@@ -1796,6 +2017,17 @@ tool("project_config", {
             "X login window and waits for them to log in. By default (false), connect_x does NOT pop a " +
             "browser window on an auto-import miss; it returns needs_login and you offer manual login as " +
             "an opt-in. The login window still opens automatically if the user DENIED the keychain prompt."),
+        reddit_source: z
+            .string()
+            .optional()
+            .describe("Optional browser profile to import the Reddit session from, e.g. 'arc:Default', " +
+            "'chrome:Profile 1'. Default: auto-detect the browser that holds a reddit.com session."),
+        reddit_manual_login: z
+            .boolean()
+            .optional()
+            .describe("Set true ONLY when the user explicitly wants to sign into Reddit by hand. Opens a focused " +
+            "Reddit login window in the autoposter's reddit browser and waits. Same opt-in discipline " +
+            "as x_manual_login."),
         name: z
             .string()
             .optional()
@@ -1965,6 +2197,130 @@ tool("project_config", {
                     : "X is not connected yet. " + summarizeXAuth(r),
         });
     }
+    // ---- List Reddit import sources (read-only, no keychain prompt) --------
+    if (args.action === "detect_reddit_sources") {
+        const r = await redditDetectSources();
+        return jsonContent({
+            action: "detect_reddit_sources",
+            ok: r.ok,
+            sources: r.sources,
+            recommended: r.recommended,
+            error: r.error,
+        });
+    }
+    // ---- Connect Reddit: OPTIONAL platform, mirrors connect_x --------------
+    // Preview-or-run, same confirm-first shape as connect_x. Reddit is never
+    // required for onboarding completion; offer it only after X setup is done
+    // and the user wants it.
+    if (args.action === "connect_reddit") {
+        if (args.confirm !== true) {
+            // Cheap probe so the explanation reflects current state (no Chrome launch).
+            const cur = await redditStatus();
+            if (cur.connected) {
+                return jsonContent({
+                    action: "connect_reddit",
+                    already_connected: true,
+                    state: cur.state,
+                    username: cur.username,
+                    note: "Reddit is already connected in the autoposter's reddit browser. Nothing to import.",
+                });
+            }
+            return jsonContent({
+                action: "connect_reddit",
+                requires_confirmation: true,
+                current_state: cur.state,
+                what_will_happen: "To engage on Reddit for you, the autoposter uses its OWN managed Google Chrome (separate " +
+                    "from your everyday browser and from the X one). It needs your logged-in reddit.com " +
+                    "session. If you confirm, it will: (1) start that managed reddit browser if it isn't " +
+                    "running, (2) copy ONLY your reddit.com cookies (reddit_session, token_v2) from your " +
+                    "everyday browser (Chrome/Arc/Brave/Edge, auto-detected) into it, and (3) verify you're " +
+                    "logged in via Reddit's own me.json. No other site's cookies are read, and your passwords " +
+                    "are never seen. If it can't import a valid session, a Chrome window will open for you to " +
+                    "sign in once.",
+                keychain_prompt: "Reading the saved session requires macOS to unlock the browser's encrypted cookie store, so " +
+                    "one or more keychain prompts will appear (“... wants to use your confidential information " +
+                    "stored in '... Safe Storage' in your keychain”). This is expected. The user enters their Mac " +
+                    "login password and clicks Allow (or Always Allow to avoid repeats). If they use more than one " +
+                    "browser, the prompt can appear a few times, once per browser.",
+                say_to_user: "Heads up: your Mac will pop up a keychain prompt asking to use your browser's Safe Storage. " +
+                    "That's just us reading your saved Reddit login, nothing else. Type your Mac login password and " +
+                    "click Allow (or Always Allow). If you use more than one browser you may see it a couple of " +
+                    "times, once per browser.",
+                how_to_proceed: "If the user explicitly requested connecting Reddit, relay the say_to_user line as a brief " +
+                    "heads-up and immediately call project_config again with action:'connect_reddit', confirm:true; " +
+                    "do not wait for another yes/no reply. Optionally pass a reddit_source from " +
+                    "detect_reddit_sources. If the user only asked what connection would do, stop after this " +
+                    "preview. Reddit is OPTIONAL: never treat it as required for setup completion.",
+            });
+        }
+        recordOnboardingAttempt("reddit_connected", {
+            state: args.reddit_source ? "source_selected" : "auto_detect",
+        });
+        const r = await redditConnect(args.reddit_source, args.reddit_manual_login);
+        let verified = false;
+        let configNote;
+        if (r.connected) {
+            completeOnboardingMilestone("reddit_connected", { state: r.state });
+            // Persist the discovered username through the server's config-write
+            // path (accounts.reddit.username, the field account_resolver reads),
+            // never overwriting a deliberately-set value.
+            if (r.username) {
+                const w = recordRedditAccount(r.username);
+                configNote = w.detail;
+            }
+            // Doctor-style persistence re-check before reddit_verified: a fresh
+            // read-only status probe confirms the session actually persisted
+            // (live me.json or the on-disk profile cookie row) rather than
+            // trusting the connect call's own success.
+            const recheck = await redditStatus();
+            if (recheck.connected) {
+                completeOnboardingMilestone("reddit_verified", { state: recheck.state });
+                verified = true;
+            }
+            else {
+                recordOnboardingAttempt("reddit_verified", {
+                    state: recheck.state || "unverified",
+                });
+            }
+            // Reddit is live: install the discovery kicker (idempotent; gated on
+            // runtime + project readiness inside, and it never touches a
+            // hand-built plist pointing outside the managed package).
+            void ensureRedditKickerInstalled()
+                .then((res) => console.error(`[reddit-kicker] post-connect install: ${res.ok ? "ok" : "skip"} (${res.detail})`))
+                .catch((e) => console.error("[reddit-kicker] post-connect install failed:", e?.message || e));
+        }
+        else {
+            blockOnboardingMilestone("reddit_connected", `reddit_${r.state || "not_connected"}`, r.error || r.note || summarizeRedditAuth(r), { state: r.state || "not_connected" });
+        }
+        return jsonContent({
+            action: "connect_reddit",
+            connected: r.connected,
+            state: r.state,
+            username: r.username,
+            account_age_days: r.account_age_days,
+            comment_karma: r.comment_karma,
+            // Ready-to-relay expectation setter for fresh/low-karma accounts
+            // (AutoMod gates those in most subreddits). Advisory only; never a
+            // reason to block or undo the connect.
+            warning: r.warning,
+            verified,
+            config: configNote,
+            summary: summarizeRedditAuth(r),
+            note: r.note,
+            attempts: r.attempts,
+            onboarding: onboardingSnapshot(),
+            next_step: r.connected
+                ? "Reddit is connected. The reddit discovery job installs itself once a project is " +
+                    "configured; drafts flow into the same review cards as X and nothing posts without " +
+                    "approval." +
+                    (r.warning ? " Relay the `warning` field to the user so expectations are set." : "")
+                : r.state === "needs_login"
+                    ? "The user must finish signing in to reddit.com in the Chrome window that opened. Tell " +
+                        "them that single required action, then call project_config action:'connect_reddit', " +
+                        "confirm:true again."
+                    : "Reddit is not connected yet. " + summarizeRedditAuth(r),
+        });
+    }
     // ---- Profile scan: grounding-truth corpus from the connected account ----
     // Reuses the authenticated managed-Chrome session (so it must run AFTER a
     // successful connect_x) to read the user's bio + recent posts + recent
@@ -2070,6 +2426,9 @@ tool("project_config", {
         const projects = Array.isArray(snap.projects) ? snap.projects : [];
         const rtReady = !!snap.runtime_ready;
         const xConnected = !!snap.x_connected;
+        const redditConnected = !!snap.reddit_connected;
+        // Any-of platform completion: X or Reddit satisfies the platform leg.
+        const anyPlatform = xConnected || redditConnected;
         const configured = (snap.projects_ready || 0) > 0;
         return jsonContent({
             configured,
@@ -2078,6 +2437,9 @@ tool("project_config", {
             x_connected: xConnected,
             x_state: snap.x_state,
             x_handle: snap.x_handle ?? null,
+            reddit_connected: redditConnected,
+            reddit_state: snap.reddit_state,
+            reddit_username: snap.reddit_username ?? null,
             setup_complete: !!snap.setup_complete,
             mcp_version: snap.version,
             latest_version: snap.latest_version,
@@ -2099,14 +2461,15 @@ tool("project_config", {
                 ? "Runtime is not ready yet. It provisions automatically on boot — poll runtime action:'status' until ready (only call runtime action:'install' to retry if status shows the boot provision failed or stalled), then continue setup automatically."
                 : projects.length === 0
                     ? "No projects yet. Discover the product from conversation context and the connected X profile; research its website, infer a conservative complete project, and call project_config. Ask only if no product can be identified." +
-                        (xConnected ? "" : " X is not connected yet either — detect_x_sources, warn about keychain prompts, then run connect_x with confirm:true without a separate permission turn.")
+                        (anyPlatform ? "" : " No platform is connected yet either. X is the default: detect_x_sources, warn about keychain prompts, then run connect_x with confirm:true without a separate permission turn. If the user prefers Reddit (or X can't be connected), connect_reddit works standalone.")
                     : projects.every((p) => p.ready)
-                        ? (xConnected
-                            ? "All configured projects are ready and X is connected. SCHEDULE THE AUTOPILOT: (1) call queue_setup and create each returned task with create_scheduled_task (prompt and notifyOnCompletion verbatim — notifyOnCompletion must be false; 'already exists' is fine, but then call update_scheduled_task with notifyOnCompletion:false to silence per-run notifications); (2) the autopilot then runs on its own (launchd kicker + queue worker). Call the `dashboard` tool to confirm the schedule is firing (schedule_state 'ok') — that is the terminal step; do NOT wait for or verify a draft card. Do NOT pause to ask the user to review drafts."
-                            : "All configured projects are ready, but X is NOT connected — posting needs a logged-in " +
-                                "x.com session. Detect sources and run project_config action:'connect_x', confirm:true; do not ask whether to proceed.")
+                        ? (anyPlatform
+                            ? "All configured projects are ready and a platform is connected" +
+                                (xConnected ? "" : " (Reddit; X was skipped, which is fine)") +
+                                ". SCHEDULE THE AUTOPILOT: (1) call queue_setup and create each returned task with create_scheduled_task (prompt and notifyOnCompletion verbatim — notifyOnCompletion must be false; 'already exists' is fine, but then call update_scheduled_task with notifyOnCompletion:false to silence per-run notifications); (2) the autopilot then runs on its own (launchd kicker + queue worker). Call the `dashboard` tool to confirm the schedule is firing (schedule_state 'ok') — that is the terminal step; do NOT wait for or verify a draft card. Do NOT pause to ask the user to review drafts."
+                            : "All configured projects are ready, but NO platform is connected yet; posting needs a logged-in session. X is the default: detect sources and run project_config action:'connect_x', confirm:true; do not ask whether to proceed. If the user prefers Reddit or X can't be connected, run action:'connect_reddit' instead; ONE connected platform completes setup.")
                         : "Some projects are missing required fields (see each project's missing_required). Derive them from config, context, profile_scan, and website research, then call project_config again. Ask only if a required field is genuinely unknowable." +
-                            (xConnected ? "" : " X is also not connected yet; detect sources and run connect_x with confirm:true."),
+                            (anyPlatform ? "" : " No platform is connected yet either; X is the default (connect_x with confirm:true), or connect_reddit if the user prefers Reddit."),
         });
     }
     // Apply mode (incremental): merge whatever fields were supplied onto the
@@ -2332,6 +2695,27 @@ tool("post_drafts", {
         }
         c.approved = false;
         rejected.push(n);
+        // Reddit cards: also retire the reddit_candidates row (permanent
+        // mark_attempt) so Phase 0 salvage never re-pulls and re-drafts a
+        // thread a human just rejected. Twitter gets this for free via the
+        // review-events row flip; reddit's id-keyed flows are deliberately
+        // firewalled (rd- prefixed ids), so this direct by-thread-url PATCH is
+        // the reddit equivalent. Fire-and-forget: a failure leaves the row
+        // pending, which at worst re-drafts one card next cycle.
+        const ccr = c;
+        if (ccr.platform === "reddit" && (ccr.thread_url || ccr.candidate_url)) {
+            const rejUrl = String(ccr.thread_url || ccr.candidate_url);
+            void runPython("-c", [
+                "import sys; sys.path.insert(0, 'scripts')\n" +
+                    "from http_api import api_patch\n" +
+                    "api_patch('/api/v1/reddit-candidates/by-thread-url', " +
+                    "{'thread_url': sys.argv[1], 'action': 'mark_attempt', " +
+                    "'reason': 'human_rejected', 'permanent': True}, ok_on_404=True)",
+                rejUrl,
+            ], { timeoutMs: 30_000 }).catch(() => {
+                /* best effort */
+            });
+        }
     });
     // Apply edits first; an edited draft is always posted.
     const approve = new Set();
@@ -2686,9 +3070,9 @@ tool("posting_volume", {
     title: "Read or set posting volume (Aggressive / Steady / Chill)",
     description: "Read or set this install's posting-volume mode, the quality bar that decides how many drafts " +
         "per day the twitter cycle produces. Three modes, shown to users as Aggressive (~100+ posts/day), " +
-        "Steady (~30/day), and Chill (~5/day, only the very best candidates); 'default' clears the " +
-        "override so the cycle's built-in setting applies. Internally the modes are high|medium|low and " +
-        "both spellings are accepted. action:'get' returns the current mode plus per-mode estimated " +
+        "Steady (~30/day, the default every install starts on), and Chill (~5/day, only the very best " +
+        "candidates). Internally the modes are high|medium|low and both spellings are accepted. " +
+        "action:'get' returns the current mode plus per-mode estimated " +
         "posts/day computed from this install's own recent candidate pool (show those numbers with the " +
         "Aggressive/Steady/Chill names when the user is choosing). Use when the user asks to post more, " +
         "post less, slow down, be more aggressive, chill out, raise the quality bar, or change posting " +
@@ -2697,9 +3081,9 @@ tool("posting_volume", {
     inputSchema: {
         action: z.enum(["get", "set"]).default("get").describe("get = read mode + rates; set = change it"),
         mode: z
-            .enum(["aggressive", "steady", "chill", "high", "medium", "low", "default"])
+            .enum(["aggressive", "steady", "chill", "high", "medium", "low"])
             .optional()
-            .describe("Required for action:'set'. aggressive=high, steady=medium, chill=low; 'default' clears the override."),
+            .describe("Required for action:'set'. aggressive=high, steady=medium, chill=low."),
     },
 }, async (args) => {
     const action = args.action || "get";
@@ -2707,7 +3091,7 @@ tool("posting_volume", {
     const ALIAS = { aggressive: "high", steady: "medium", chill: "low" };
     if (action === "set") {
         if (!args.mode) {
-            return jsonContent({ error: "mode is required for action:'set' (aggressive|steady|chill|default)" });
+            return jsonContent({ error: "mode is required for action:'set' (aggressive|steady|chill)" });
         }
         const stored = ALIAS[String(args.mode)] || String(args.mode);
         const r = await runPython("scripts/s4l_posting_mode.py", ["set", stored], {
@@ -3620,6 +4004,101 @@ async function ensureQueueKickerInstalled() {
         return { ok: false, detail: e?.message || String(e) };
     }
 }
+// ---- Reddit discovery kicker (optional platform) ----------------------------
+// Mirrors ensureQueueKickerInstalled for the reddit lane: a 15-minute launchd
+// job that runs skill/run-reddit-search-launchd.sh (the detach wrapper; the
+// real cycle honors the global draft-only flag via s4l_mode.py, and its
+// drafting turn rides the same s4l-worker queue as X). Gates:
+//   - runtime ready
+//   - reddit connected (connected OR connected_idle; the profile persists)
+//   - a managed project is configured and ready
+// It is NEVER an onboarding requirement: installs that never connect reddit
+// simply never get this plist.
+//
+// OPERATOR-MAC SAFETY: a hand-built com.m13v.social-reddit-search plist
+// pointing at ~/social-autoposter (StartCalendarInterval, custom env) exists
+// on the dev box. If an existing plist's program path is not the managed
+// package's wrapper, we log and leave it completely alone: no rewrite, no
+// reload, no unload.
+async function ensureRedditKickerInstalled() {
+    try {
+        if (process.platform !== "darwin")
+            return { ok: false, detail: "not macOS" };
+        if (!runtimeReady())
+            return { ok: false, detail: "runtime not ready" };
+        const productReady = listManagedProjectStatus().some((p) => p.ready);
+        if (!productReady)
+            return { ok: false, detail: "no ready project yet" };
+        // Reddit session gate. status is read-only (never launches Chrome): a live
+        // me.json validation when the harness is up, the on-disk profile cookie
+        // check (connected_idle) when it isn't.
+        const rs = await redditStatus();
+        if (!rs.connected) {
+            return { ok: false, detail: `reddit not connected (${rs.state})` };
+        }
+        const managedWrapper = path.join(repoDir(), "skill", "run-reddit-search-launchd.sh");
+        // Foreign-plist guard BEFORE any write: if a plist already exists and its
+        // ProgramArguments do not point at the managed package's wrapper, it is a
+        // hand-built / operator arrangement. Leave it untouched.
+        let cur = null;
+        try {
+            cur = fs.readFileSync(REDDIT_SEARCH_PLIST, "utf-8");
+        }
+        catch {
+            cur = null;
+        }
+        if (cur !== null && !cur.includes(`<string>${managedWrapper}</string>`)) {
+            const msg = `existing ${REDDIT_SEARCH_LABEL} plist points outside the managed package; leaving it untouched`;
+            console.error(`[reddit-kicker] ${msg}`);
+            return { ok: true, detail: `skip: ${msg}` };
+        }
+        const logDir = path.join(repoDir(), "skill", "logs");
+        try {
+            fs.mkdirSync(logDir, { recursive: true });
+        }
+        catch {
+            /* best-effort */
+        }
+        const xml = plistXml({
+            label: REDDIT_SEARCH_LABEL,
+            programArgs: ["bash", managedWrapper],
+            intervalSecs: REDDIT_SEARCH_INTERVAL_SECS,
+            runAtLoad: false, // never fire a discovery cycle the instant Claude launches
+            stdoutLog: path.join(logDir, "launchd-reddit-search-stdout.log"),
+            stderrLog: path.join(logDir, "launchd-reddit-search-stderr.log"),
+            // S4L_REPO_DIR + S4L_PYTHON are baked by plistXml. State dir + CDP url
+            // pin the wrapper's children to the managed state and the harness port.
+            extraEnv: {
+                S4L_STATE_DIR: s4lStateDir(),
+                REDDIT_CDP_URL: REDDIT_CDP_URL_DEFAULT,
+            },
+            // The wrapper double-forks the real cycle into its own session already,
+            // but keep launchd away from the harness Chrome all the same.
+            abandonProcessGroup: true,
+        });
+        const uid = process.getuid ? process.getuid() : 0;
+        if (cur === xml) {
+            const res = await loadPlist(REDDIT_SEARCH_LABEL, REDDIT_SEARCH_PLIST, uid);
+            return { ok: true, detail: `current (load rc=${res.code})` };
+        }
+        if (cur !== null) {
+            await unloadPlist(REDDIT_SEARCH_LABEL, REDDIT_SEARCH_PLIST, uid);
+        }
+        fs.mkdirSync(path.dirname(REDDIT_SEARCH_PLIST), { recursive: true });
+        fs.writeFileSync(REDDIT_SEARCH_PLIST, xml, "utf-8");
+        const res = await loadPlist(REDDIT_SEARCH_LABEL, REDDIT_SEARCH_PLIST, uid);
+        // No first-run kickstart on purpose: reddit discovery is a background
+        // add-on, and the connect flow just finished using the harness browser.
+        // The first StartInterval tick (≤15 min) is soon enough.
+        return {
+            ok: true,
+            detail: cur === null ? "installed + loaded" : `rewritten + reloaded (rc=${res.code})`,
+        };
+    }
+    catch (e) {
+        return { ok: false, detail: e?.message || String(e) };
+    }
+}
 // ---- launchd reaper: kill leaked agent-mode claude worker sessions ----------
 // Independent guardrail (NOT gated on a project being ready): the leak happens
 // whenever the scheduled-task workers fire, and a no-leak run is a cheap no-op.
@@ -4107,6 +4586,13 @@ async function buildSnapshot() {
         completeOnboardingMilestone("runtime_ready");
     if (snap.x_connected)
         completeOnboardingMilestone("x_connected", { state: snap.x_state || "connected" });
+    // Reddit (optional platform) heal: a live connected reading on a LATER poll
+    // is itself persistence evidence, so it may also complete reddit_verified
+    // for an install whose post-connect verify probe transiently failed.
+    if (snap.reddit_connected) {
+        completeOnboardingMilestone("reddit_connected", { state: snap.reddit_state || "connected" });
+        completeOnboardingMilestone("reddit_verified", { source: "live_snapshot" });
+    }
     if ((snap.projects_ready || 0) > 0)
         completeOnboardingMilestone("project_ready", { missing_count: 0 });
     if (snap.schedule_state === "ok")
@@ -5150,6 +5636,12 @@ async function main() {
     // disk, BEFORE serving, so the very first scan uses the shipped pipeline (not
     // the version first materialized at install). Synchronous + best-effort.
     ensurePipelineCurrent();
+    // Config's canonical home is the state dir (2026-07-13): migrate a legacy
+    // in-repo config.json up on first boot after update, keep the legacy path
+    // working via symlink, and self-heal a missing/wrong link on every boot.
+    // Must run AFTER ensurePipelineCurrent() so repoDir() points at the final
+    // materialized repo.
+    console.error(`[social-autoposter-mcp] config home: ${ensureConfigInStateDir()}`);
     // Deterministically provision the owned runtime on boot: whenever it isn't
     // ready (a fresh install, or one interrupted mid-way because a step failed or
     // Claude/the host died mid-install) kick the full install in the background
@@ -5205,6 +5697,17 @@ async function main() {
     else {
         console.error("[queue-worker] launchd kicker: skip (paused)");
     }
+    // Reddit discovery kicker (optional platform): installs only when reddit is
+    // connected AND a project is ready; a box that never connected reddit is a
+    // cheap no-op skip. Paused-gated like the X kicker (it produces drafts).
+    if (!isPaused()) {
+        void ensureRedditKickerInstalled()
+            .then((r) => console.error(`[reddit-kicker] launchd kicker: ${r.ok ? "ok" : "skip"} (${r.detail})`))
+            .catch((e) => console.error("[reddit-kicker] kicker install failed:", e?.message || e));
+    }
+    else {
+        console.error("[reddit-kicker] launchd kicker: skip (paused)");
+    }
     // Self-healing reaper for the agent-mode session leak the queue autopilot
     // produces (finished `claude` worker sessions Desktop never tears down). A
     // standalone guardrail; install unconditionally so it caps memory even on a