genpark-outreach-warmer

9 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

• SKILL.md1.2 KB084e815a9f82upstream ↗

  ---
  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.
  

• README.md2.0 KB2fe6bf90ec97upstream ↗

  # 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.
  

• .gitignore64 Bed8ae579cca3upstream ↗

  __pycache__/\n*.py[cod]\n.env\n.venv/\nvenv/\n*.log\n.DS_Store\n

• client.py5.8 KB4c19b7025f8aupstream ↗

  # -*- 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)
              }
          }
  

• example_usage.py1.1 KB6a1303483b7cupstream ↗

  # -*- 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']})")
  

• LICENSE1.0 KBbafb53b2fc92upstream ↗

  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.
  

• mcp_server.py2.1 KB9ef9e9ae9ee1upstream ↗

  # -*- 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()
  

• requirements.txt76 B0528add65f81upstream ↗

  # Zero external dependencies required -- Python 3.9+ standard library only\n

• skill.json402 B315e2549d36fupstream ↗

  {
    "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"
    ]
  }

Plain-text copy, no login: /skill-bundles/alpha-park-openclaw-genpark-outreach-warmer.md