# genpark-outreach-warmer Adopt this skill: https://proskills.md/skills/other/alpha-park-openclaw-genpark-outreach-warmer Page: https://proskills.md/skills/other/alpha-park-openclaw-genpark-outreach-warmer This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required. ## File: SKILL.md size: 1275 sha: 084e815a9f8244973d6ed9fdfb09ec2ac6c14f89 upstream: https://github.com/alpha-park/openclaw-genpark-outreach-warmer/blob/HEAD/SKILL.md ```text --- name: genpark-outreach-warmer description: B2B Cold Email Reputation and Domain Warm-up automation. version: 1.0.0 --- # genpark-outreach-warmer ## Overview Email deliverability is the lifeblood of cold outbound marketing. This skill coordinates a swarm of GenPark agents to emulate human conversational behavior across hundreds of email inboxes. By writing personalized emails, marking them as 'Not Spam', and replying organically, it artificially builds domain reputation to guarantee high primary inbox placement rates. ## Core Capabilities - **Peer-to-Peer Sending**: Distribute emails among a controlled network of inboxes to build sending history safely. - **Spam Trap Recovery**: Monitor if emails land in the spam folder, move them to the inbox, and mark them as important. - **Natural Language Replies**: Read incoming warm-up emails and generate contextual, unique replies to mimic organic human communication. ## Usage Guide When starting a warm-up campaign: 1. Ensure IMAP/SMTP details are provided for the target inbox. 2. Determine the daily ramp-up limit (e.g., Day 1: 5 emails, Day 2: 10 emails). 3. Draft dynamic, conversational strings (no direct selling) for the warm-up cycle. 4. Provide the user with a weekly deliverability health score metric. ``` ## File: README.md size: 2071 sha: 2fe6bf90ec975d15e828d788197205150a4a7015 upstream: https://github.com/alpha-park/openclaw-genpark-outreach-warmer/blob/HEAD/README.md ````text # openclaw-genpark-outreach-warmer [![OpenClaw](https://img.shields.io/badge/OpenClaw-Ecosystem-blue.svg)](https://github.com/alphaparkinc/openclaw-genpark-outreach-warmer) [![Zero Dependency](https://img.shields.io/badge/Dependencies-Standard_Library_Only-success.svg)](https://www.python.org/) [![MCP Ready](https://img.shields.io/badge/MCP-Model_Context_Protocol-orange.svg)](https://modelcontextprotocol.io/) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Production Grade](https://img.shields.io/badge/Status-Production_Ready-brightgreen.svg)](https://github.com/Alpha-Park/openclaw-genpark-outreach-warmer) Production-grade agentic micro-skill designed for the OpenClaw and GenPark swarms. Built strictly using the Python standard library with zero external runtime dependencies. ## Architecture & Flow ```mermaid flowchart TD A[Agent Planner / Host] -->|Tool Invocation| B(MCP Server Entrypoint) B --> C[OpenClawGenParkOutreachWarmer] C --> D[Deterministic Mathematical Algorithms] D --> E[Validated JSON Response] E -->|Structured Payload| A ``` ## Features - **Standard Library Only**: 100% Python standard library with no wheels, C-extensions, or pip requirements. - **Model Context Protocol (MCP)**: Native FastMCP JSON-RPC interface for seamless tool-calling in Claude, Cursor, and OpenClaw. - **Algorithmic Rigor**: Rigorous closed-form mathematical equations and quantitative deterministic metrics. - **Multi-Tenant Mirrored**: Dual-deployed across `@alphaparkinc` and `@Alpha-Park`. ## Installation & Usage ```bash git clone https://github.com/Alpha-Park/openclaw-genpark-outreach-warmer.git cd openclaw-genpark-outreach-warmer python example_usage.py ``` ## MCP Configuration Add to your `claude_desktop_config.json`: ```json { "mcpServers": { "openclaw-genpark-outreach-warmer": { "command": "python", "args": ["-m", "openclaw-genpark-outreach-warmer.mcp_server"] } } } ``` ## License MIT License. See [LICENSE](LICENSE) for details. ```` ## File: .gitignore size: 64 sha: ed8ae579cca3201f66148b37156e8f84a58a6680 upstream: https://github.com/alpha-park/openclaw-genpark-outreach-warmer/blob/HEAD/.gitignore ```text __pycache__/\n*.py[cod]\n.env\n.venv/\nvenv/\n*.log\n.DS_Store\n ``` ## File: client.py size: 5952 sha: 4c19b7025f8afc88aec857baf7fa930e03921fb6 upstream: https://github.com/alpha-park/openclaw-genpark-outreach-warmer/blob/HEAD/client.py ```text # -*- coding: utf-8 -*- """ OpenClaw GenPark Outreach Warmer Client Pure Python Standard Library (Zero External Dependencies) Implements sigmoid email ramp-up volume progression, SPF/DKIM/DMARC authentication posture scoring, and sender reputation domain decay modeling. """ import math from typing import Dict, Any, List, Optional class OpenClawGenParkOutreachWarmer: """ Email deliverability optimization and domain warmup engine for outbound AI agents. """ def __init__(self): pass def calculate_sigmoid_rampup_schedule( self, target_daily_volume: int = 500, warmup_days: int = 21, midpoint_day: float = 10.5, growth_steepness: float = 0.35 ) -> Dict[str, Any]: """ Calculates daily sending volume schedule using a continuous generalized logistic (sigmoid) function: V(t) = ceil( target_volume / (1 + exp(-k * (t - t0))) ) """ days = max(7, warmup_days) target = max(10, target_daily_volume) schedule = [] cumulative_volume = 0 for day in range(1, days + 1): # Sigmoid formula exponent = -growth_steepness * (day - midpoint_day) sigmoid_val = 1.0 / (1.0 + math.exp(max(-50.0, min(50.0, exponent)))) daily_vol = max(5, math.ceil(target * sigmoid_val)) # Safe burst limit (no more than 30% of daily total per hour) max_hourly_burst = max(2, math.ceil(daily_vol * 0.25)) cumulative_volume += daily_vol schedule.append({ "day": day, "recommended_daily_volume": daily_vol, "max_hourly_burst": max_hourly_burst, "ramp_percentage": round((daily_vol / target) * 100.0, 1), "cumulative_volume": cumulative_volume }) return { "target_daily_volume": target, "warmup_days": days, "total_warmup_volume_dispatched": cumulative_volume, "schedule": schedule } def validate_email_auth_alignment_records( self, spf_record: str, dkim_selector_length: int = 2048, dmarc_policy: str = "reject" ) -> Dict[str, Any]: """ Evaluates email authentication alignment posture across SPF, DKIM, and DMARC. Assigns an overall deliverability security posture score (0 - 100). """ score = 0.0 checks = {} # 1. SPF Evaluation (35 points max) spf_score = 0.0 spf_clean = spf_record.strip().lower() if "v=spf1" in spf_clean: spf_score += 15.0 if "-all" in spf_clean: spf_score += 20.0 # Hard fail is strict checks["spf_posture"] = "STRICT_HARDFAIL" elif "~all" in spf_clean: spf_score += 12.0 # Soft fail is acceptable checks["spf_posture"] = "MODERATE_SOFTFAIL" else: checks["spf_posture"] = "WEAK_PERMISSIVE" else: checks["spf_posture"] = "MISSING_OR_INVALID" score += spf_score # 2. DKIM Evaluation (35 points max) dkim_score = 0.0 if dkim_selector_length >= 2048: dkim_score = 35.0 checks["dkim_posture"] = "ROBUST_2048_BIT" elif dkim_selector_length >= 1024: dkim_score = 20.0 checks["dkim_posture"] = "LEGACY_1024_BIT" else: checks["dkim_posture"] = "INSUFFICIENT_KEY_LENGTH" score += dkim_score # 3. DMARC Policy Evaluation (30 points max) dmarc_clean = dmarc_policy.strip().lower() dmarc_score = 0.0 if dmarc_clean == "reject": dmarc_score = 30.0 checks["dmarc_posture"] = "STRICT_REJECT" elif dmarc_clean == "quarantine": dmarc_score = 20.0 checks["dmarc_posture"] = "MODERATE_QUARANTINE" elif dmarc_clean == "none": dmarc_score = 8.0 checks["dmarc_posture"] = "MONITORING_ONLY" else: checks["dmarc_posture"] = "MISSING_POLICY" score += dmarc_score posture = "EXCELLENT" if score >= 85 else ("ACCEPTABLE" if score >= 65 else "AT_RISK_SPAM_BOX") return { "overall_posture_score": round(score, 1), "deliverability_posture": posture, "spf_score": spf_score, "dkim_score": dkim_score, "dmarc_score": dmarc_score, "detailed_checks": checks } def estimate_domain_reputation_decay( self, baseline_score: float = 95.0, bounce_rate_pct: float = 1.5, spam_complaint_rate_pct: float = 0.05, days_idle: int = 0 ) -> Dict[str, Any]: """ Estimates sender reputation degradation under bounce penalties, complaint multipliers, and inactive dormancy decay: Penalty = (Bounce * 4.0) + (Spam * 50.0) + (DaysIdle * 0.5) """ bounce_penalty = max(0.0, bounce_rate_pct) * 4.0 spam_penalty = max(0.0, spam_complaint_rate_pct) * 60.0 dormancy_penalty = max(0, days_idle) * 0.4 total_penalty = bounce_penalty + spam_penalty + dormancy_penalty projected_reputation = max(0.0, round(baseline_score - total_penalty, 2)) status = "HEALTHY" if projected_reputation >= 80 else ("CAUTION" if projected_reputation >= 60 else "THROTTLED_SUSPENDED") return { "baseline_score": baseline_score, "projected_reputation_score": projected_reputation, "reputation_status": status, "penalties": { "bounce_penalty": round(bounce_penalty, 2), "spam_complaint_penalty": round(spam_penalty, 2), "dormancy_penalty": round(dormancy_penalty, 2), "total_penalty": round(total_penalty, 2) } } ``` ## File: example_usage.py size: 1120 sha: 6a1303483b7c0cce19aaf0ec175d249f84f4e478 upstream: https://github.com/alpha-park/openclaw-genpark-outreach-warmer/blob/HEAD/example_usage.py ```text # -*- coding: utf-8 -*- from client import OpenClawGenParkOutreachWarmer warmer = OpenClawGenParkOutreachWarmer() # 1. Sigmoid Warmup Schedule sched = warmer.calculate_sigmoid_rampup_schedule(target_daily_volume=400, warmup_days=14) print(f"Sigmoid Warmup: Target {sched['target_daily_volume']}/day over {sched['warmup_days']} days (Total: {sched['total_warmup_volume_dispatched']})") for d in sched['schedule'][::3]: print(f" Day {d['day']}: {d['recommended_daily_volume']} emails/day (Max burst: {d['max_hourly_burst']}/hr, {d['ramp_percentage']}%)") # 2. DNS Auth Alignment auth = warmer.validate_email_auth_alignment_records( spf_record="v=spf1 include:_spf.google.com ~all", dkim_selector_length=2048, dmarc_policy="reject" ) print(f"\nAuthentication Posture: Score={auth['overall_posture_score']}/100 ({auth['deliverability_posture']})") # 3. Reputation Decay Forecast rep = warmer.estimate_domain_reputation_decay(baseline_score=98.0, bounce_rate_pct=2.1, spam_complaint_rate_pct=0.08) print(f"\nReputation Projection: Score={rep['projected_reputation_score']} ({rep['reputation_status']})") ``` ## File: LICENSE size: 1071 sha: bafb53b2fc9253ffcac08bb8f6e8a474ddf0a5d2 upstream: https://github.com/alpha-park/openclaw-genpark-outreach-warmer/blob/HEAD/LICENSE ```text MIT License Copyright (c) 2026 AlphaPark Inc. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ``` ## File: mcp_server.py size: 2159 sha: 9ef9e9ae9ee1de55c1507b99c4b38bceb7d590d8 upstream: https://github.com/alpha-park/openclaw-genpark-outreach-warmer/blob/HEAD/mcp_server.py ```text # -*- coding: utf-8 -*- """ OpenClaw GenPark Outreach Warmer MCP Server FastMCP standard interface for email deliverability ramp-up and domain authentication audits. """ import json from typing import Dict, Any from client import OpenClawGenParkOutreachWarmer try: from mcp.server.fastmcp import FastMCP mcp = FastMCP("openclaw-genpark-outreach-warmer") except ImportError: class MockFastMCP: def __init__(self, name): self.name = name def tool(self): def decorator(f): return f return decorator mcp = MockFastMCP("openclaw-genpark-outreach-warmer") warmer = OpenClawGenParkOutreachWarmer() @mcp.tool() def calculate_sigmoid_rampup_schedule( target_daily_volume: int = 500, warmup_days: int = 21, midpoint_day: float = 10.5, growth_steepness: float = 0.35 ) -> str: """ Calculates daily sending volume schedule using a continuous generalized logistic (sigmoid) function. """ res = warmer.calculate_sigmoid_rampup_schedule(target_daily_volume, warmup_days, midpoint_day, growth_steepness) return json.dumps(res, indent=2) @mcp.tool() def validate_email_auth_alignment_records( spf_record: str, dkim_selector_length: int = 2048, dmarc_policy: str = "reject" ) -> str: """ Evaluates email authentication alignment posture across SPF, DKIM, and DMARC. """ res = warmer.validate_email_auth_alignment_records(spf_record, dkim_selector_length, dmarc_policy) return json.dumps(res, indent=2) @mcp.tool() def estimate_domain_reputation_decay( baseline_score: float = 95.0, bounce_rate_pct: float = 1.5, spam_complaint_rate_pct: float = 0.05, days_idle: int = 0 ) -> str: """ Estimates sender reputation degradation under bounce penalties, complaint multipliers, and inactivity. """ res = warmer.estimate_domain_reputation_decay(baseline_score, bounce_rate_pct, spam_complaint_rate_pct, days_idle) return json.dumps(res, indent=2) def main(): print("Testing Outreach Warmer:") print(calculate_sigmoid_rampup_schedule(300, 14)) if __name__ == "__main__": main() ``` ## File: requirements.txt size: 76 sha: 0528add65f81b98e5d4083b7522a6a0ba35bc019 upstream: https://github.com/alpha-park/openclaw-genpark-outreach-warmer/blob/HEAD/requirements.txt ```text # Zero external dependencies required -- Python 3.9+ standard library only\n ``` ## File: skill.json size: 402 sha: 315e2549d36f7cba46442f078d6943c9129ca0c8 upstream: https://github.com/alpha-park/openclaw-genpark-outreach-warmer/blob/HEAD/skill.json ```text { "name": "openclaw-genpark-outreach-warmer", "version": "1.0.0", "description": "OpenClaw GenPark Outreach Warmer - Sigmoid email ramp-up volume progression, SPF/DKIM/DMARC authentication posture scoring, and sender reputation domain decay modeling.", "tools": [ "calculate_sigmoid_rampup_schedule", "validate_email_auth_alignment_records", "estimate_domain_reputation_decay" ] } ```