email-compose

name	email_compose
version	1.0.0
agent	email
risk_level	high
description	Compose and send emails via SMTP. Support for plain text, HTML, attachments, templates, and mail merge. Includes draft review before sending.

Email Compose Skill

Purpose

Compose, draft, and send emails on behalf of the Animus Forge system. This skill enables automated email workflows including notifications, reports, outreach, and responses. Due to the irreversible nature of sending emails, this skill requires elevated consensus for send operations.

Safety Rules

CRITICAL - EMAIL IS IRREVERSIBLE

1. ALWAYS create draft first, send only after approval
2. NEVER send without Triumvirate UNANIMOUS consensus
3. ALWAYS confirm recipient addresses before sending
4. NEVER send to large recipient lists without explicit approval
5. NEVER include sensitive data in email body

ANTI-SPAM REQUIREMENTS

1. Respect unsubscribe requests
2. Include clear sender identification
3. Don't spoof headers or sender addresses
4. Rate limit outbound messages
5. Keep mailing lists opt-in only

CONSENSUS REQUIREMENTS

Operation	Risk Level	Consensus Required
create_draft	low	any
review_draft	low	any
send_email	critical	unanimous + user confirmation
send_bulk	critical	unanimous + user confirmation
add_attachment	medium	majority

Configuration

Email credentials should be stored securely, never in code:

# ~/.gorgon/config/email.yaml (chmod 600)
smtp:
  host: smtp.gmail.com
  port: 587
  use_tls: true
  username: ${GORGON_EMAIL_USER}
  password: ${GORGON_EMAIL_PASS}  # Use app password for Gmail

defaults:
  from_name: "Animus Forge"
  from_address: "[e-mail]"
  reply_to: "[e-mail]"
  signature: |
    --
    Sent by Animus Forge Automation System
    This is an automated message.

Capabilities

create_draft

Create an email draft for review before sending.

from dataclasses import dataclass
from typing import Optional
from datetime import datetime
import json
from pathlib import Path

@dataclass
class EmailDraft:
    id: str
    to: list[str]
    cc: list[str]
    bcc: list[str]
    subject: str
    body_text: str
    body_html: Optional[str]
    attachments: list[str]
    created_at: str
    status: str  # "draft", "approved", "sent", "cancelled"

DRAFTS_DIR = Path.home() / ".gorgon" / "email_drafts"

def create_draft(
    to: list[str],
    subject: str,
    body: str,
    cc: list[str] = None,
    bcc: list[str] = None,
    html_body: str = None,
    attachments: list[str] = None
) -> dict:
    """Create an email draft for review."""

    DRAFTS_DIR.mkdir(parents=, exist_ok=)

    draft_id = 

    draft = EmailDraft(
        =draft_id,
        to=to,
        cc=cc  [],
        bcc=bcc  [],
        subject=subject,
        body_text=body,
        body_html=html_body,
        attachments=attachments  [],
        created_at=datetime.now().isoformat(),
        status=
    )

    
    draft_file = DRAFTS_DIR / 
    draft_file.write_text(json.dumps(draft.__dict__, indent=))

     {
        : ,
        : draft_id,
        : (draft_file),
        : {
            : to,
            : subject,
            : body[:] +   (body) >   body
        }
    }

---

review_draft

Display draft for review and approval.

def review_draft(draft_id: str) -> dict:
    """Load and display a draft for review."""

    draft_file = DRAFTS_DIR / f"{draft_id}.json"

    if not draft_file.exists():
        return {"success": False, "error": f"Draft not found: {draft_id}"}

    draft_data = json.loads(draft_file.read_text())

    # Format for display
    review = f"""
═══════════════════════════════════════════════════════════════
                     EMAIL DRAFT REVIEW
═══════════════════════════════════════════════════════════════
Draft ID: {draft_data['id']}
Created:  {draft_data['created_at']}
Status:   {draft_data['status']}
═══════════════════════════════════════════════════════════════

TO:      {', '.join(draft_data['to'])}
CC:      {', '.join(draft_data['cc']) if draft_data['cc'] else '(none)'}
BCC:     {', '.join(draft_data['bcc']) if draft_data['bcc'] else '(none)'}
SUBJECT: {draft_data['subject']}

───────────────────────────────────────────────────────────────
BODY:
───────────────────────────────────────────────────────────────
{draft_data['body_text']}
───────────────────────────────────────────────────────────────

ATTACHMENTS: 

═══════════════════════════════════════════════════════════════
    """

     {
        : ,
        : draft_id,
        : draft_data[],
        : review,
        : draft_data
    }

---

approve_draft

Mark a draft as approved for sending.

def approve_draft(draft_id: str) -> dict:
    """Mark draft as approved (requires Triumvirate unanimous consensus)."""

    draft_file = DRAFTS_DIR / f"{draft_id}.json"

    if not draft_file.exists():
        return {"success": False, "error": f"Draft not found: {draft_id}"}

    draft_data = json.loads(draft_file.read_text())

    if draft_data['status'] != 'draft':
        return {"success": False, "error": f"Draft status is {draft_data['status']}, cannot approve"}

    draft_data['status'] = 'approved'
    draft_data['approved_at'] = datetime.now().isoformat()

    draft_file.write_text(json.dumps(draft_data, indent=2))

    return {
        "success": True,
        "draft_id": draft_id,
        "status": "approved",
        "message": "Draft approved. Ready to send with send_email."
    }

---

send_email

Send an approved draft. REQUIRES UNANIMOUS CONSENSUS.

import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from email.mime.base import MIMEBase
from email import encoders
import yaml
from pathlib import Path

def load_email_config() -> dict:
    """Load email configuration."""
    config_path = Path.home() / ".gorgon" / "config" / "email.yaml"

    if not config_path.exists():
        raise FileNotFoundError("Email config not found. Create ~/.gorgon/config/email.yaml")

    with open(config_path) as f:
        return yaml.safe_load(f)

def send_email(draft_id: str, confirm: bool = False) -> dict:
    """
    Send an approved email draft.

    REQUIRES:
    - Triumvirate UNANIMOUS consensus
    - User confirmation (confirm=True)
    """

    # Load draft
    draft_file = DRAFTS_DIR / f"{draft_id}.json"

    if not draft_file.exists():
        return {"success": False, "error": f"Draft not found: {draft_id}"}

    draft_data = json.loads(draft_file.read_text())

    
     draft_data[] != :
         {
            : ,
            : 
        }

    
      confirm:
         {
            : ,
            : ,
            : draft_id,
            : draft_data[] + draft_data[] + draft_data[]
        }

    
    config = load_email_config()

    
    msg = MIMEMultipart()
    msg[] = 
    msg[] = .join(draft_data[])
    msg[] = draft_data[]

     draft_data[]:
        msg[] = .join(draft_data[])

     config[].get():
        msg[] = config[][]

    
    body_with_sig = draft_data[] + config[].get(, )
    msg.attach(MIMEText(body_with_sig, ))

     draft_data[]:
        msg.attach(MIMEText(draft_data[], ))

    
     attachment_path  draft_data[]:
        path = Path(attachment_path)
         path.exists():
             (path, )  f:
                part = MIMEBase(, )
                part.set_payload(f.read())
                encoders.encode_base64(part)
                part.add_header(
                    ,
                    
                )
                msg.attach(part)

    
    :
        all_recipients = draft_data[] + draft_data[] + draft_data[]

         smtplib.SMTP(config[][], config[][])  server:
             config[].get(, ):
                server.starttls()

            server.login(config[][], config[][])
            server.sendmail(
                config[][],
                all_recipients,
                msg.as_string()
            )

        
        draft_data[] = 
        draft_data[] = datetime.now().isoformat()
        draft_file.write_text(json.dumps(draft_data, indent=))

         {
            : ,
            : draft_id,
            : ,
            : all_recipients,
            : draft_data[]
        }

     Exception  e:
         {
            : ,
            : (e),
            : draft_id
        }

---

add_attachment

Add an attachment to a draft.

def add_attachment(draft_id: str, file_path: str) -> dict:
    """Add an attachment to an existing draft."""

    draft_file = DRAFTS_DIR / f"{draft_id}.json"

    if not draft_file.exists():
        return {"success": False, "error": f"Draft not found: {draft_id}"}

    # Verify file exists
    attachment = Path(file_path)
    if not attachment.exists():
        return {"success": False, "error": f"Attachment not found: {file_path}"}

    # Check file size (limit 25MB)
    if attachment.stat().st_size > 25 * 1024 * 1024:
        return {"success": False, "error": "Attachment too large (max 25MB)"}

    draft_data = json.loads(draft_file.read_text())

    if draft_data['status'] != 'draft':
        return {"success": False, "error": "Cannot modify approved/sent draft"}

    draft_data['attachments'].append(str(attachment.absolute()))
    draft_file.write_text(json.dumps(draft_data, indent=2))

    return {
        : ,
        : draft_id,
        : (attachment),
        : (draft_data[])
    }

---

use_template

Create a draft from a template with variable substitution.

TEMPLATES_DIR = Path.home() / ".gorgon" / "email_templates"

def use_template(
    template_name: str,
    to: list[str],
    variables: dict,
    cc: list[str] = None
) -> dict:
    """Create a draft from a template."""

    template_file = TEMPLATES_DIR / f"{template_name}.yaml"

    if not template_file.exists():
        return {"success": False, "error": f"Template not found: {template_name}"}

    with open(template_file) as f:
        template = yaml.safe_load(f)

    # Substitute variables
    subject = template['subject']
    body = template['body']

    for key, value in variables.items():
        subject = subject.replace(f"{{{{{key}}}}}", str(value))
        body = body.replace(f"{{{{{key}}}}}", str(value))

    # Check for unsubstituted variables
    import re
    remaining = re.findall(r'\{\{(\w+)\}\}', subject + body)
    if remaining:
        return {
            "success": False,
            "error": f"Missing template variables: "
        }

    
     create_draft(
        to=to,
        subject=subject,
        body=body,
        cc=cc,
        html_body=template.get()
    )

Example template file:

# ~/.gorgon/email_templates/job_followup.yaml
name: job_followup
description: Follow-up email after job application

subject: "Following up on {{position}} application - {{applicant_name}}"

body: |
  Dear {{hiring_manager}},

  I hope this email finds you well. I wanted to follow up on my application
  for the {{position}} position at {{company}} that I submitted on {{apply_date}}.

  I remain very interested in this opportunity and would welcome the chance
  to discuss how    {{}}    

             

   
  {{}}

---

Examples

Example 1: Send a status report email

Intent: "Send a daily status report to the team"

Execution:

# Step 1: Create draft (any agent can do this)
draft = create_draft(
    to=["[e-mail]"],
    cc=["[e-mail]"],
    subject="Daily Status Report - 2026-01-27",
    body="""
Team,

Here's today's status update:

COMPLETED:
- Deployed v2.3.1 to production
- Fixed authentication bug (#1234)
- Updated documentation

IN PROGRESS:
- API rate limiting implementation (80% complete)
- Performance optimization review

BLOCKED:
- Waiting on AWS credentials for staging environment

Let me know if you have questions.

Best,
Gorgon System
"""
)

print(f"Draft created: {draft['draft_id']}")

# Step 2: Review draft
review = review_draft(draft['draft_id'])
print(review['review_text'])

# Step 3: Approve (requires Triumvirate unanimous consensus)
# This would be called by the Triumvirate after review
approval = approve_draft(draft['draft_id'])
print(f"Approval status: {approval['status']}")

# Step 4: Send (requires user confirmation)
# Only after Triumvirate approval
result = send_email(draft['draft_id'], confirm=True)
print(f"Sent: {result['success']}")

---

Example 2: Use a template for job follow-up

Intent: "Send a follow-up email for my Palantir application"

Execution:

# Create draft from template
draft = use_template(
    template_name="job_followup",
    to=["[e-mail]"],
    variables={
        "position": "AI Solutions Engineer",
        "applicant_name": "ARETE",
        "hiring_manager": "Hiring Team",
        "company": "Palantir",
        "apply_date": "January 15, 2026",
        "relevant_skill": "AI enablement and enterprise operations"
    }
)

# Review
review = review_draft(draft['draft_id'])
print(review['review_text'])

# Continue with approval/send process...

---

Security Considerations

Credential Storage

# Never store credentials in plain text
# Use environment variables or encrypted secrets

# Option 1: Environment variables
export GORGON_EMAIL_USER="[e-mail]"
export GORGON_EMAIL_PASS="your-app-password"

# Option 2: Use a secrets manager
# Reference in config: ${GORGON_EMAIL_USER}

Gmail App Passwords

For Gmail, you must use an App Password:

1. Enable 2FA on your Google account
2. Go to Google Account → Security → 2-Step Verification → App passwords
3. Generate a password for "Gorgon"
4. Use this instead of your regular password

Error Handling

Error	Response
SMTP auth failed	Check credentials, verify app password
Connection refused	Check host/port, firewall settings
Recipient rejected	Verify email address format
Attachment too large	Compress or use file sharing link
Rate limited	Wait and retry, reduce send frequency

Output Format

{
  "success": true,
  "operation": "send_email",
  "draft_id": "draft_20260127_103000",
  "status": "sent",
  "recipients": ["[e-mail]", "[e-mail]"],
  "sent_at": "2026-01-27T10:35:00Z",
  "message_id": "<[e-mail]>"
}