@m13v/s4l 1.7.4 → 1.7.5-rc.10

package/mcp/dist/index.js

@@ -885,6 +885,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 +1002,105 @@ 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;
+    if (approvedReddit.length) {
+        for (const c of approvedReddit) {
+            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;
+            }
+            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: [dec],
+                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++;
+            }
+        }
+        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 (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 +1152,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 +1165,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 +1181,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 +1248,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 +1271,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 +1292,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 +1319,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 +1345,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 +1359,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"),
     };
 }
@@ -2332,6 +2439,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();
@@ -2676,6 +2804,58 @@ tool("restart_menubar", {
         menubar_running: running,
     });
 });
+// ---- posting_volume: per-install posting-volume mode (virality bar) --------
+// Server-side throttle (2026-07-13): installations.posting_mode maps to a
+// virality-bar percentile on the API (high~0.90, medium~0.97, low~0.995) and
+// OVERRIDES the cycle driver's hardcoded percentile, so a change applies on
+// the next cycle with no client update. 'get' also returns per-mode estimated
+// posts/day replayed from THIS install's trailing-7d candidate pool.
+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, 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 " +
+        "volume. Takes effect on the next cycle; in draft-review mode it equally paces how many review " +
+        "cards appear.",
+    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"])
+            .optional()
+            .describe("Required for action:'set'. aggressive=high, steady=medium, chill=low."),
+    },
+}, async (args) => {
+    const action = args.action || "get";
+    // Friendly display names map onto the stored high|medium|low enum.
+    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)" });
+        }
+        const stored = ALIAS[String(args.mode)] || String(args.mode);
+        const r = await runPython("scripts/s4l_posting_mode.py", ["set", stored], {
+            timeoutMs: 30_000,
+        });
+        try {
+            return jsonContent(JSON.parse((r.stdout || "").trim()));
+        }
+        catch {
+            return jsonContent({ error: `posting-mode set failed: ${(r.stderr || r.stdout || "").slice(0, 300)}` });
+        }
+    }
+    const r = await runPython("scripts/s4l_posting_mode.py", ["get"], { timeoutMs: 30_000 });
+    try {
+        return jsonContent(JSON.parse((r.stdout || "").trim()));
+    }
+    catch {
+        return jsonContent({ error: `posting-mode get failed: ${(r.stderr || r.stdout || "").slice(0, 300)}` });
+    }
+});
 // ---- pause_s4l: temporarily stop drafting/posting, reversibly --------------
 // The lighter alternative to Quit: unloads only the launchd jobs that scan,
 // draft, and post (plus their support daemons), leaving Claude Desktop, the