@m13v/s4l 1.7.1-rc.13 → 1.7.1-rc.15

package/mcp/dist/index.js

@@ -1181,10 +1181,21 @@ async function postApproved(batchId, plan) {
     }
     // 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
-    // the run exited non-zero OR fewer drafts posted than were approved. This is
-    // the only telemetry channel that reaches a customer .mcpb install (their cycle
-    // log lives on their machine). install_id/hostname are auto-tagged.
-    if (res.code !== 0 || realPosted < approved.length) {
+    // the run exited non-zero OR a REAL failure happened. This is the only
+    // telemetry channel that reaches a customer .mcpb install (their cycle log
+    // lives on their machine). install_id/hostname are auto-tagged.
+    //
+    // Gated on failure_reasons (not just realPosted < approved.length): the
+    // Python pipeline already reports every shortfall to Sentry itself
+    // (twitter_post_plan.py's capture_message), including benign skips like a
+    // deleted target tweet. Re-reporting the SAME benign skip here as a second,
+    // independently-fingerprinted `Error` (this capture group) doubled every
+    // such event into two distinct Sentry issues. Only add this Node-side
+    // capture when there's a real failure_reasons entry or a non-zero exit,
+    // i.e. something the Python capture wouldn't already have flagged as an
+    // 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})`), {
             component: "post",
             exit_code: String(res.code),
@@ -1594,7 +1605,10 @@ tool("engagement_mode", {
     // persona is seeded. (2026-06-30) Skipped when promotion-only, since the
     // product project isn't configured yet (it stays gated until project_config).
     let kickerInstall = null;
-    if (personalBrand) {
+    if (personalBrand && isPaused()) {
+        kickerInstall = { ok: false, detail: "skip (paused)" };
+    }
+    else if (personalBrand) {
         try {
             kickerInstall = await ensureQueueKickerInstalled();
             console.error(`[engagement_mode] launchd kicker: ${kickerInstall.ok ? "ok" : "skip"} (${kickerInstall.detail})`);
@@ -2088,7 +2102,10 @@ tool("project_config", {
         // persona-aware, so calling it from both setup paths is safe. Best-effort:
         // a kicker hiccup never fails setup. (2026-06-30)
         let kickerInstall = null;
-        if (result.ready) {
+        if (result.ready && isPaused()) {
+            kickerInstall = { ok: false, detail: "skip (paused)" };
+        }
+        else if (result.ready) {
             try {
                 kickerInstall = await ensureQueueKickerInstalled();
                 console.error(`[project_config] launchd kicker: ${kickerInstall.ok ? "ok" : "skip"} (${kickerInstall.detail})`);
@@ -2484,6 +2501,7 @@ tool("runtime", {
     return jsonContent({
         ...snapshot,
         menubar_running: await menubarRunning(),
+        paused: isPaused(),
         onboarding: onboardingSnapshot(),
     });
 });
@@ -2514,6 +2532,37 @@ tool("restart_menubar", {
         menubar_running: running,
     });
 });
+// ---- 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
+// S4L tray, X connection, and the draft schedule registration untouched.
+// Fully reversible — action:'resume' reinstalls the exact same daemons via the
+// same idempotent ensure*Installed() functions boot uses. NOT "autopilot": S4L
+// is draft-first (a human approves every post), so this pauses/resumes the
+// draft pipeline itself, not some autonomous posting mode.
+tool("pause_s4l", {
+    title: "Pause or resume S4L",
+    description: "Pause temporarily stops S4L's own draft pipeline (the launchd kicker that scans/drafts/posts, " +
+        "plus its reaper/stall-watch/memory-snapshot support jobs) WITHOUT touching Claude Desktop, the " +
+        "S4L tray, your X connection, or the draft schedule registration — nothing is deleted, so it " +
+        "survives a Claude Desktop restart and Resume brings it right back. Use when the user asks to " +
+        "pause, stop, or temporarily disable S4L, or to resume/unpause it. This is NOT the same as Quit " +
+        "(which kills and restarts Claude Desktop and removes the draft schedule) — Pause is the lighter, " +
+        "fully reversible option. action:'status' (default) reports whether it's currently paused.",
+    inputSchema: {
+        action: z.enum(["status", "pause", "resume"]).optional(),
+    },
+}, async ({ action }) => {
+    if (action === "pause") {
+        const res = await pauseS4L();
+        return jsonContent({ action: "pause", paused: isPaused(), ...res });
+    }
+    if (action === "resume") {
+        const res = await resumeS4L();
+        return jsonContent({ action: "resume", paused: isPaused(), ...res });
+    }
+    return jsonContent({ action: "status", paused: isPaused() });
+});
 // ---- report_diagnosis: ship a field diagnosis to the developers -------------
 // First-class MCP wrapper over scripts/send_diagnostic_report.py (the same
 // Sentry lane the menubar "Diagnose & fix" prompt uses). Before this existed
@@ -3576,6 +3625,76 @@ async function ensureMemorySnapshotInstalled() {
         return { ok: false, detail: e?.message || String(e) };
     }
 }
+// ---- pause/resume: stop drafting/posting without touching Claude Desktop ---
+// Unlike Quit (which kills + relaunches Claude Desktop and deletes the draft
+// schedule), Pause only unloads the launchd jobs that actually DO work — the
+// kicker that scans/drafts/posts (TWITTER_AUTOPILOT_LABEL) plus its reaper,
+// stall-watch, and memory-snapshot support daemons — while leaving Claude
+// Desktop, the tray, and the Claude-native s4l-worker scheduled task alone.
+// The scheduled task still fires on its own cadence; claude_job.py's `next`
+// checks the same flag file and reports "no work" instantly instead of
+// draining the queue, so nothing drafts or posts while paused even if a
+// worker session wakes up mid-pause. A flag file (nothing is deleted) is what
+// makes Resume a plain reinstall of the same 4 daemons — see resumeS4L.
+function pauseFlagPath() {
+    return path.join(s4lStateDir(), "paused.flag");
+}
+function isPaused() {
+    try {
+        return fs.existsSync(pauseFlagPath());
+    }
+    catch {
+        return false;
+    }
+}
+const PAUSE_TARGETS = [
+    { label: TWITTER_AUTOPILOT_LABEL, plist: TWITTER_AUTOPILOT_PLIST },
+    { label: REAPER_LABEL, plist: REAPER_PLIST },
+    { label: STALL_WATCH_LABEL, plist: STALL_WATCH_PLIST },
+    { label: MEMORY_SNAPSHOT_LABEL, plist: MEMORY_SNAPSHOT_PLIST },
+];
+async function pauseS4L() {
+    if (isPaused())
+        return { ok: true, detail: "already paused" };
+    try {
+        fs.mkdirSync(path.dirname(pauseFlagPath()), { recursive: true });
+        fs.writeFileSync(pauseFlagPath(), `paused at ${new Date().toISOString()}\n`, "utf-8");
+    }
+    catch (e) {
+        return { ok: false, detail: `could not write pause flag: ${e?.message || e}` };
+    }
+    const uid = process.getuid ? process.getuid() : 0;
+    const results = [];
+    for (const { label, plist } of PAUSE_TARGETS) {
+        try {
+            const res = await unloadPlist(label, plist, uid);
+            results.push(`${label}: unloaded (rc=${res.code})`);
+        }
+        catch (e) {
+            results.push(`${label}: ${e?.message || e}`);
+        }
+    }
+    return { ok: true, detail: results.join("; ") };
+}
+async function resumeS4L() {
+    try {
+        fs.rmSync(pauseFlagPath(), { force: true });
+    }
+    catch {
+        /* best-effort */
+    }
+    const kicker = await ensureQueueKickerInstalled();
+    const reaper = await ensureClaudeReaperInstalled();
+    const stall = await ensureStallWatchInstalled();
+    const mem = await ensureMemorySnapshotInstalled();
+    const detail = [
+        `kicker: ${kicker.ok ? "ok" : "skip"} (${kicker.detail})`,
+        `reaper: ${reaper.ok ? "ok" : "skip"} (${reaper.detail})`,
+        `stall-watch: ${stall.ok ? "ok" : "skip"} (${stall.detail})`,
+        `memory-snapshot: ${mem.ok ? "ok" : "skip"} (${mem.detail})`,
+    ].join("; ");
+    return { ok: true, detail };
+}
 // Install/refresh the on-screen overlay watcher launchd job. Promotes the
 // harness status overlay from a best-effort, fired-from-other-tools nicety to a
 // first-class self-healing job. We run `harness_overlay.py watch` directly in
@@ -3771,6 +3890,7 @@ async function buildSnapshot() {
     // (it's a launchctl check the Node side owns), so layer it on here. The panel
     // uses it to offer a one-click "restart menu bar" when the tray was quit.
     snap.menubar_running = await menubarRunning();
+    snap.paused = isPaused();
     await ensureDoctorPhase(snap.x_connected ? "full" : "pre_connect");
     if (snap.runtime_ready)
         completeOnboardingMilestone("runtime_ready");
@@ -4806,16 +4926,31 @@ async function main() {
     catch (e) {
         console.error(`[queue-worker] could not create worker folder: ${e?.message || e}`);
     }
-    void ensureQueueKickerInstalled()
-        .then((r) => console.error(`[queue-worker] launchd kicker: ${r.ok ? "ok" : "skip"} (${r.detail})`))
-        .catch((e) => console.error("[queue-worker] kicker install failed:", e?.message || e));
+    // The 4 pipeline daemons (kicker, reaper, stall-watch, memory-snapshot) are
+    // skipped at boot while paused.flag is present, so a Claude Desktop restart
+    // during a Pause doesn't silently un-pause the pipeline — see pauseS4L/
+    // resumeS4L. Feedback-digest is NOT gated: it only distills past review
+    // decisions, not drafting/posting, so it's harmless to keep running.
+    if (!isPaused()) {
+        void ensureQueueKickerInstalled()
+            .then((r) => console.error(`[queue-worker] launchd kicker: ${r.ok ? "ok" : "skip"} (${r.detail})`))
+            .catch((e) => console.error("[queue-worker] kicker install failed:", e?.message || e));
+    }
+    else {
+        console.error("[queue-worker] 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
     // box whose project isn't ready yet. Best-effort; must never block boot.
-    void ensureClaudeReaperInstalled()
-        .then((r) => console.error(`[claude-reaper] launchd reaper: ${r.ok ? "ok" : "skip"} (${r.detail})`))
-        .catch((e) => console.error("[claude-reaper] reaper install failed:", e?.message || e));
+    if (!isPaused()) {
+        void ensureClaudeReaperInstalled()
+            .then((r) => console.error(`[claude-reaper] launchd reaper: ${r.ok ? "ok" : "skip"} (${r.detail})`))
+            .catch((e) => console.error("[claude-reaper] reaper install failed:", e?.message || e));
+    }
+    else {
+        console.error("[claude-reaper] launchd reaper: skip (paused)");
+    }
     // Feedback digest: hourly distillation of the user's card approve/reject
     // decisions into learned_preferences (see scripts/feedback_digest.py).
     // Best-effort; a box with no review events runs a no-op.
@@ -4825,15 +4960,25 @@ async function main() {
     // Autopilot stall watchdog: fleet-side Sentry alert when the draft routines stop
     // draining (most often an account switch orphaning them). The menu bar shows the
     // user the Re-arm action; this is the part we see. Best-effort; never blocks boot.
-    void ensureStallWatchInstalled()
-        .then((r) => console.error(`[stall-watch] launchd watchdog: ${r.ok ? "ok" : "skip"} (${r.detail})`))
-        .catch((e) => console.error("[stall-watch] watchdog install failed:", e?.message || e));
+    if (!isPaused()) {
+        void ensureStallWatchInstalled()
+            .then((r) => console.error(`[stall-watch] launchd watchdog: ${r.ok ? "ok" : "skip"} (${r.detail})`))
+            .catch((e) => console.error("[stall-watch] watchdog install failed:", e?.message || e));
+    }
+    else {
+        console.error("[stall-watch] launchd watchdog: skip (paused)");
+    }
     // Periodic host-resource sampler (memory/process snapshot -> local JSONL). Gives
     // us per-box resource history to diagnose RAM blowups (e.g. the agent-mode
     // session leak). Best-effort; never blocks boot. Disable with S4L_MEMORY_SNAPSHOT=0.
-    void ensureMemorySnapshotInstalled()
-        .then((r) => console.error(`[memory-snapshot] launchd sampler: ${r.ok ? "ok" : "skip"} (${r.detail})`))
-        .catch((e) => console.error("[memory-snapshot] sampler install failed:", e?.message || e));
+    if (!isPaused()) {
+        void ensureMemorySnapshotInstalled()
+            .then((r) => console.error(`[memory-snapshot] launchd sampler: ${r.ok ? "ok" : "skip"} (${r.detail})`))
+            .catch((e) => console.error("[memory-snapshot] sampler install failed:", e?.message || e));
+    }
+    else {
+        console.error("[memory-snapshot] launchd sampler: skip (paused)");
+    }
     // On-screen overlay watcher supervisor. The harness status overlay only renders
     // while the watcher process is alive, and that watcher had no supervisor — when
     // it died nothing respawned it and the overlay silently vanished. Install it as