delimit-cli 4.0.2 → 4.0.4

package/gateway/ai/notify.py

@@ -23,21 +23,81 @@ from email.mime.text import MIMEText
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
+import threading
+import time as _time
+
 try:
     import yaml as _yaml
 except ImportError:
     _yaml = None  # type: ignore[assignment]
 
+# ── Email Throttle (Consensus 123: Storm Prevention) ────────────────
+# - Max 5 immediate emails per hour
+# - Non-P0 notifications batch into 15-minute digests
+# - P0 always sends immediately (bypasses throttle)
+_email_throttle_lock = threading.Lock()
+_email_send_times: list = []  # timestamps of recent sends
+_email_digest_queue: list = []  # batched non-urgent emails
+_EMAIL_MAX_PER_HOUR = 5
+_EMAIL_DIGEST_INTERVAL = 900  # 15 minutes
+_last_digest_flush = 0.0
+
 logger = logging.getLogger("delimit.ai.notify")
 
 HISTORY_FILE = Path.home() / ".delimit" / "notifications.jsonl"
 INBOX_ROUTING_FILE = Path.home() / ".delimit" / "inbox_routing.jsonl"
+OWNER_ACTIONS_FILE = Path.home() / ".delimit" / "owner_actions.jsonl"
+
+def _load_json_file(path: Path) -> Dict[str, Any]:
+    try:
+        if not path.exists():
+            return {}
+        with open(path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        return data if isinstance(data, dict) else {}
+    except (OSError, json.JSONDecodeError):
+        return {}
+
+
+def _load_secret_value(*names: str) -> str:
+    """Load a secret value from ~/.delimit/secrets/<NAME>.json files."""
+    secrets_dir = Path.home() / ".delimit" / "secrets"
+    for name in names:
+        data = _load_json_file(secrets_dir / f"{name}.json")
+        value = data.get("value") or data.get("token") or data.get("access_token") or ""
+        if value:
+            return str(value)
+    return ""
+
+
+def _load_inbound_email_config() -> Dict[str, str]:
+    secrets_dir = Path.home() / ".delimit" / "secrets"
+    smtp_accounts = _load_json_file(secrets_dir / "smtp-all.json")
+    defaults = smtp_accounts.get("_defaults", {}) if isinstance(smtp_accounts.get("_defaults"), dict) else {}
+    account_name = str(defaults.get("from_account") or "pro@delimit.ai")
+    account = smtp_accounts.get(account_name, {}) if isinstance(smtp_accounts.get(account_name), dict) else {}
+    forward_cfg = _load_json_file(secrets_dir / "forward-to.json")
+
+    return {
+        "imap_host": str(account.get("host") or ""),
+        "imap_port": str(account.get("imap_port") or "993"),
+        "imap_user": str(account.get("user") or account_name or ""),
+        "forward_to": str(
+            os.environ.get("DELIMIT_FORWARD_TO", "")
+            or forward_cfg.get("value")
+            or forward_cfg.get("to")
+            or defaults.get("to")
+            or ""
+        ),
+    }
+
 
 # ── Inbound email configuration ──────────────────────────────────────
-IMAP_HOST = "mail.spacemail.com"
-IMAP_PORT = 993
-IMAP_USER = "pro@delimit.ai"
-FORWARD_TO = "owner@example.com"
+_INBOUND_CFG = _load_inbound_email_config()
+IMAP_HOST = os.environ.get("DELIMIT_IMAP_HOST", "") or _INBOUND_CFG.get("imap_host", "")
+IMAP_PORT = int(os.environ.get("DELIMIT_IMAP_PORT", "") or _INBOUND_CFG.get("imap_port", "993"))
+IMAP_USER = os.environ.get("DELIMIT_IMAP_USER", "") or _INBOUND_CFG.get("imap_user", "")
+FORWARD_TO = _INBOUND_CFG.get("forward_to", "")
 
 # Domains/senders whose emails require owner action
 OWNER_ACTION_DOMAINS = {
@@ -60,9 +120,9 @@ OWNER_ACTION_DOMAINS = {
     "digitalocean.com",
 }
 
-OWNER_ACTION_SENDERS = {
-    "owner@example.com",
-}
+OWNER_ACTION_SENDERS = set(
+    filter(None, [os.environ.get("DELIMIT_OWNER_EMAIL", "")])
+)
 
 # Subject patterns that indicate owner-action (compiled once)
 import re as _re
@@ -98,6 +158,21 @@ def _record_notification(entry: Dict[str, Any]) -> None:
         logger.warning("Failed to record notification: %s", e)
 
 
+def record_owner_action(entry: Dict[str, Any]) -> None:
+    """Append an owner-action record for dashboard and async fanout."""
+    try:
+        OWNER_ACTIONS_FILE.parent.mkdir(parents=True, exist_ok=True)
+        payload = {
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "status": "open",
+            **entry,
+        }
+        with open(OWNER_ACTIONS_FILE, "a", encoding="utf-8") as f:
+            f.write(json.dumps(payload) + "\n")
+    except OSError as e:
+        logger.warning("Failed to record owner action: %s", e)
+
+
 def _post_json(url: str, payload: Dict[str, Any], timeout: int = 10) -> Dict[str, Any]:
     """POST a JSON payload to a URL. Returns status dict."""
     data = json.dumps(payload).encode("utf-8")
@@ -188,6 +263,43 @@ def send_slack(
     }
 
 
+def send_telegram(
+    message: str,
+    event_type: str = "",
+    bot_token: str = "",
+    chat_id: str = "",
+) -> Dict[str, Any]:
+    """Send a Telegram message via bot API."""
+    bot_token = bot_token or os.environ.get("DELIMIT_TELEGRAM_BOT_TOKEN", "") or _load_secret_value("DELIMIT_TELEGRAM_BOT_TOKEN", "TELEGRAM_MONITOR_BOT_TOKEN")
+    chat_id = chat_id or os.environ.get("DELIMIT_TELEGRAM_CHAT_ID", "") or _load_secret_value("DELIMIT_TELEGRAM_CHAT_ID", "TELEGRAM_MONITOR_CHAT_ID")
+    if not bot_token or not chat_id:
+        return {"error": "telegram bot token and chat id are required"}
+
+    timestamp = datetime.now(timezone.utc).isoformat()
+    prefix = f"[{event_type}] " if event_type else ""
+    payload = {
+        "chat_id": chat_id,
+        "text": f"{prefix}{message}",
+        "disable_web_page_preview": False,
+    }
+    url = f"https://api.telegram.org/bot{bot_token}/sendMessage"
+    result = _post_json(url, payload)
+    _record_notification({
+        "channel": "telegram",
+        "event_type": event_type,
+        "message": message,
+        "timestamp": timestamp,
+        "success": result.get("success", False),
+    })
+    return {
+        "channel": "telegram",
+        "delivered": result.get("success", False),
+        "status_code": result.get("status_code"),
+        "timestamp": timestamp,
+        "error": result.get("error"),
+    }
+
+
 def _load_smtp_account(from_account: str) -> Optional[Dict[str, str]]:
     """Load SMTP credentials from smtp-all.json for a given account.
 
@@ -211,6 +323,381 @@ def _load_smtp_account(from_account: str) -> Optional[Dict[str, str]]:
         return None
 
 
+def _flush_email_digest():
+    """Send all queued non-urgent emails as a single digest."""
+    global _email_digest_queue
+    if not _email_digest_queue:
+        return
+
+    items = list(_email_digest_queue)
+    _email_digest_queue.clear()
+
+    digest_body = f"Delimit Notification Digest ({len(items)} items)\n{'=' * 50}\n\n"
+    for i, item in enumerate(items, 1):
+        digest_body += f"--- [{i}] {item.get('subject', 'No subject')} ---\n"
+        digest_body += f"{item.get('body', '')[:500]}\n\n"
+
+    # Send digest as a single email (bypasses throttle since it IS the flush)
+    _email_send_times.append(_time.time())
+    digest_subject = f"[DIGEST] {len(items)} Delimit notifications"
+    timestamp = datetime.now(timezone.utc).isoformat()
+    try:
+        from_acct = items[0].get("from_account", "") if items else ""
+        smtp_to = items[0].get("to", "") if items else ""
+        if not smtp_to:
+            defaults = _load_smtp_account("_defaults") or {}
+            smtp_to = str(defaults.get("to") or os.environ.get("DELIMIT_SMTP_TO", ""))
+        delivered = _send_smtp_direct(
+            to=smtp_to,
+            subject=digest_subject,
+            body=digest_body,
+            from_account=from_acct,
+        )
+        _record_notification({
+            "channel": "email",
+            "event_type": "digest",
+            "to": smtp_to,
+            "from": from_acct or "pro@delimit.ai",
+            "subject": digest_subject,
+            "message": digest_body,
+            "timestamp": timestamp,
+            "success": delivered,
+            "items": len(items),
+        })
+        if delivered:
+            logger.info("Flushed email digest: %d items", len(items))
+        else:
+            logger.warning("Digest flush failed: no SMTP recipient or SMTP send returned false")
+    except Exception as e:
+        logger.warning("Digest flush failed: %s", e)
+
+
+def _send_smtp_direct(to: str, subject: str, body: str, from_account: str = "") -> bool:
+    """Low-level SMTP send — used by digest flush and direct sends."""
+    if not from_account:
+        defaults = _load_smtp_account("_defaults")
+        if defaults and defaults.get("from_account"):
+            from_account = str(defaults["from_account"])
+
+    acct = _load_smtp_account(from_account) if from_account else None
+    smtp_host = (acct or {}).get("host", os.environ.get("DELIMIT_SMTP_HOST", "smtp.gmail.com"))
+    smtp_port = int((acct or {}).get("port", os.environ.get("DELIMIT_SMTP_PORT", "587")))
+    smtp_user = (acct or {}).get("user", os.environ.get("DELIMIT_SMTP_USER", ""))
+    smtp_pass = (acct or {}).get("pass", os.environ.get("DELIMIT_SMTP_PASS", ""))
+    smtp_from = (acct or {}).get("from", smtp_user)
+
+    if not smtp_pass:
+        return False
+
+    msg = MIMEText(body, "plain", "utf-8")
+    msg["Subject"] = subject
+    msg["From"] = smtp_from
+    msg["To"] = to
+
+    try:
+        with smtplib.SMTP(smtp_host, smtp_port, timeout=15) as server:
+            server.starttls()
+            server.login(smtp_user, smtp_pass)
+            server.sendmail(smtp_from, [to], msg.as_string())
+        return True
+    except Exception as e:
+        logger.error("SMTP send failed: %s", e)
+        return False
+
+
+def _render_html_email(subject: str, body: str, event_type: str) -> str:
+    """Render a professional HTML email from a plain-text body.
+
+    Converts markdown-like patterns to HTML:
+    - Lines starting with "---" become <hr>
+    - Lines with ALL CAPS become section headers
+    - Lines starting with "- " become list items
+    - URLs become clickable links
+    - Draft text in quotes gets styled as blockquotes
+    - "approve/reject" instructions get styled as action buttons
+    """
+    import re
+    import html as _html
+
+    # Determine accent color from event type
+    color_map = {
+        "social_draft": "#7C3AED",   # purple — approval needed
+        "outreach": "#7C3AED",
+        "deploy": "#059669",          # green — deploy/success
+        "gate_failure": "#DC2626",    # red — failure/alert
+        "digest": "#2563EB",          # blue — informational
+        "info": "#2563EB",
+    }
+    accent = color_map.get(event_type, "#7C3AED")
+
+    # Parse subject for badge
+    badge = ""
+    badge_match = re.match(r'\[([A-Z]+)\]', subject)
+    if badge_match:
+        badge = badge_match.group(1)
+
+    def _render_copy_block(label: str, text: str) -> str:
+        escaped_text = _html.escape(text.strip("\n"))
+        escaped_label = _html.escape(label)
+        return (
+            f'<div style="margin:14px 0">'
+            f'<div style="background:{accent};color:white;padding:8px 12px;'
+            f'border-radius:8px 8px 0 0;font-size:12px;font-weight:700;letter-spacing:0.3px">'
+            f'{escaped_label}</div>'
+            f'<div style="border:1px solid #D1D5DB;border-top:none;border-radius:0 0 8px 8px;'
+            f'background:#F9FAFB;padding:12px">'
+            f'<div style="font-size:11px;color:#6B7280;margin-bottom:8px">'
+            f'Tap and hold inside this block to copy.</div>'
+            f'<pre style="margin:0;white-space:pre-wrap;word-break:break-word;'
+            f'font:13px/1.55 SFMono-Regular,Consolas,Monaco,monospace;color:#111827">'
+            f'{escaped_text}</pre>'
+            f'</div>'
+            f'</div>'
+        )
+
+    # Convert body lines to HTML
+    lines = body.split("\n")
+    html_lines = []
+    in_list = False
+    active_copy_label = None
+    active_copy_lines = []
+
+    for line in lines:
+        stripped = line.strip()
+
+        if stripped.startswith("--- COPY BELOW THIS LINE ---"):
+            if in_list:
+                html_lines.append("</ul>")
+                in_list = False
+            active_copy_label = "Manual Post Text"
+            active_copy_lines = []
+            continue
+
+        if stripped.startswith("--- TITLE (paste in title field) ---"):
+            if in_list:
+                html_lines.append("</ul>")
+                in_list = False
+            active_copy_label = "Post Title"
+            active_copy_lines = []
+            continue
+
+        if stripped.startswith("--- BODY (paste in body field) ---"):
+            if active_copy_label and active_copy_lines:
+                html_lines.append(_render_copy_block(active_copy_label, "\n".join(active_copy_lines)))
+            if in_list:
+                html_lines.append("</ul>")
+                in_list = False
+            active_copy_label = "Post Body"
+            active_copy_lines = []
+            continue
+
+        if stripped.startswith("--- SOURCE POST TITLE ---"):
+            if active_copy_label and active_copy_lines:
+                html_lines.append(_render_copy_block(active_copy_label, "\n".join(active_copy_lines)))
+            if in_list:
+                html_lines.append("</ul>")
+                in_list = False
+            active_copy_label = "Source Post Title"
+            active_copy_lines = []
+            continue
+
+        if stripped.startswith("--- SOURCE POST BODY ---"):
+            if active_copy_label and active_copy_lines:
+                html_lines.append(_render_copy_block(active_copy_label, "\n".join(active_copy_lines)))
+            if in_list:
+                html_lines.append("</ul>")
+                in_list = False
+            active_copy_label = "Source Post Body"
+            active_copy_lines = []
+            continue
+
+        if stripped == "--- END ---" and active_copy_label is not None:
+            html_lines.append(_render_copy_block(active_copy_label, "\n".join(active_copy_lines)))
+            active_copy_label = None
+            active_copy_lines = []
+            continue
+
+        if active_copy_label is not None:
+            active_copy_lines.append(line)
+            continue
+
+        if not stripped:
+            if in_list:
+                html_lines.append("</ul>")
+                in_list = False
+            html_lines.append("<br>")
+            continue
+
+        # Draft block headers: "--- Draft <id> (platform) ---"
+        if stripped.startswith("--- Draft ") and stripped.endswith("---"):
+            if in_list:
+                html_lines.append("</ul>")
+                in_list = False
+            draft_label = _html.escape(stripped.strip("- ").strip())
+            html_lines.append(
+                f'<div style="background:{accent};color:white;padding:8px 14px;'
+                f'border-radius:6px 6px 0 0;margin-top:16px;font-size:13px;font-weight:700">'
+                f'{draft_label}</div>'
+                f'<div style="background:#F9FAFB;border:1px solid #E5E7EB;border-top:none;'
+                f'border-radius:0 0 6px 6px;padding:12px 14px;margin-bottom:4px">'
+            )
+            # The next lines until the next "---" or "To approve" will be inside this box
+            # We'll close it when we hit the next separator
+            continue
+
+        # Horizontal rules / separators
+        if stripped.startswith("---") or stripped.startswith("==="):
+            if in_list:
+                html_lines.append("</ul>")
+                in_list = False
+            # Close any open draft box
+            html_lines.append('</div>')
+            html_lines.append(f'<hr style="border:none;border-top:1px solid #E5E7EB;margin:16px 0">')
+            continue
+
+        # Section headers (ALL CAPS lines or lines ending with colon that are short)
+        if (stripped.isupper() and len(stripped) > 3 and len(stripped) < 60) or \
+           (stripped.endswith(":") and len(stripped) < 50 and stripped[:-1].replace(" ", "").replace("-", "").isalpha()):
+            if in_list:
+                html_lines.append("</ul>")
+                in_list = False
+            html_lines.append(
+                f'<h3 style="color:{accent};font-size:13px;font-weight:700;'
+                f'text-transform:uppercase;letter-spacing:0.5px;margin:20px 0 8px 0;'
+                f'border-bottom:2px solid {accent};padding-bottom:4px">'
+                f'{_html.escape(stripped)}</h3>'
+            )
+            continue
+
+        # List items
+        if stripped.startswith("- ") or stripped.startswith("* "):
+            if not in_list:
+                html_lines.append('<ul style="margin:4px 0;padding-left:20px">')
+                in_list = True
+            item = _html.escape(stripped[2:])
+            # Bold draft IDs
+            item = re.sub(r'([0-9a-f]{12})', r'<code style="background:#F3F4F6;padding:1px 4px;border-radius:3px;font-size:12px">\1</code>', item)
+            html_lines.append(f'<li style="margin:4px 0;color:#374151">{item}</li>')
+            continue
+
+        if in_list:
+            html_lines.append("</ul>")
+            in_list = False
+
+        escaped = _html.escape(stripped)
+
+        # Convert URLs to clickable links
+        escaped = re.sub(
+            r'(https?://[^\s<>&"]+)',
+            r'<a href="\1" style="color:{};text-decoration:underline">\1</a>'.format(accent),
+            escaped,
+        )
+
+        # Style quoted draft text
+        if escaped.startswith('"') and escaped.endswith('"'):
+            html_lines.append(
+                f'<blockquote style="border-left:3px solid {accent};margin:8px 0;'
+                f'padding:8px 12px;background:#F9FAFB;color:#374151;font-style:italic">'
+                f'{escaped}</blockquote>'
+            )
+            continue
+
+        # Style approve/reject instructions as action callouts
+        if any(kw in stripped.lower() for kw in ("to approve", "reply with", "reply \"approve")):
+            html_lines.append(
+                f'<div style="background:#F0FDF4;border:1px solid #BBF7D0;border-radius:6px;'
+                f'padding:10px 14px;margin:12px 0;font-weight:600;color:#166534">'
+                f'{escaped}</div>'
+            )
+            continue
+
+        if any(kw in stripped.lower() for kw in ("to reject", "reply \"reject")):
+            html_lines.append(
+                f'<div style="background:#FEF2F2;border:1px solid #FECACA;border-radius:6px;'
+                f'padding:10px 14px;margin:12px 0;color:#991B1B">'
+                f'{escaped}</div>'
+            )
+            continue
+
+        # Protocol warnings
+        if "PROTOCOL WARNING" in stripped:
+            html_lines.append(
+                f'<div style="background:#FEF3C7;border:1px solid #FDE68A;border-radius:6px;'
+                f'padding:10px 14px;margin:12px 0;color:#92400E;font-size:12px">'
+                f'{escaped}</div>'
+            )
+            continue
+
+        # Regular paragraph
+        html_lines.append(f'<p style="margin:6px 0;color:#374151;line-height:1.5">{escaped}</p>')
+
+    if in_list:
+        html_lines.append("</ul>")
+
+    body_html = "\n".join(html_lines)
+
+    # Build full HTML email
+    badge_html = ""
+    if badge:
+        badge_colors = {
+            "APPROVE": ("#7C3AED", "#EDE9FE"),
+            "ACTION": ("#D97706", "#FEF3C7"),
+            "ALERT": ("#DC2626", "#FEE2E2"),
+            "URGENT": ("#DC2626", "#FEE2E2"),
+            "GATE": ("#DC2626", "#FEE2E2"),
+            "DIGEST": ("#2563EB", "#DBEAFE"),
+            "INFO": ("#6B7280", "#F3F4F6"),
+            "OUTREACH": ("#7C3AED", "#EDE9FE"),
+            "DEPLOY": ("#059669", "#D1FAE5"),
+        }
+        fg, bg = badge_colors.get(badge, ("#6B7280", "#F3F4F6"))
+        badge_html = (
+            f'<span style="display:inline-block;background:{bg};color:{fg};'
+            f'font-size:11px;font-weight:700;padding:2px 8px;border-radius:4px;'
+            f'letter-spacing:0.5px;margin-bottom:8px">{badge}</span><br>'
+        )
+
+    # Clean subject for display (remove bracket prefix)
+    display_subject = re.sub(r'^\[[A-Z]+\]\s*', '', subject)
+
+    return f"""<!DOCTYPE html>
+<html>
+<head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"></head>
+<body style="margin:0;padding:0;background:#F9FAFB;font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif">
+<table width="100%" cellpadding="0" cellspacing="0" style="background:#F9FAFB;padding:20px 0">
+<tr><td align="center">
+<table width="600" cellpadding="0" cellspacing="0" style="background:#FFFFFF;border-radius:8px;box-shadow:0 1px 3px rgba(0,0,0,0.1);overflow:hidden">
+
+<!-- Header bar -->
+<tr><td style="background:{accent};padding:16px 24px">
+  <table width="100%" cellpadding="0" cellspacing="0"><tr>
+    <td><span style="color:white;font-size:14px;font-weight:700;letter-spacing:0.5px">DELIMIT</span></td>
+    <td align="right"><span style="color:rgba(255,255,255,0.8);font-size:11px">{event_type or 'notification'}</span></td>
+  </tr></table>
+</td></tr>
+
+<!-- Body -->
+<tr><td style="padding:24px">
+  {badge_html}
+  <h2 style="margin:0 0 16px 0;color:#111827;font-size:18px;font-weight:600;line-height:1.3">{_html.escape(display_subject)}</h2>
+  {body_html}
+</td></tr>
+
+<!-- Footer -->
+<tr><td style="background:#F9FAFB;padding:12px 24px;border-top:1px solid #E5E7EB">
+  <table width="100%" cellpadding="0" cellspacing="0"><tr>
+    <td><span style="color:#9CA3AF;font-size:11px">Sent by Delimit governance layer</span></td>
+    <td align="right"><a href="https://delimit.ai" style="color:#9CA3AF;font-size:11px;text-decoration:none">delimit.ai</a></td>
+  </tr></table>
+</td></tr>
+
+</table>
+</td></tr>
+</table>
+</body>
+</html>"""
+
+
 def send_email(
     to: str = "",
     subject: str = "",
@@ -241,8 +728,46 @@ def send_email(
     email_body = body or message
 
     timestamp = datetime.now(timezone.utc).isoformat()
+    event_key = (event_type or "").lower()
+    force_digest = event_key in ("social_draft", "outreach")
+
+    # ── Throttle: batch non-urgent, always send P0/immediate ──
+    is_urgent = (not force_digest) and any(tag in event_key + (subject or "").lower()
+                    for tag in ("p0", "urgent", "alert", "critical", "social_draft", "approve",
+                                "founder_directive", "gate_failure"))
+
+    global _last_digest_flush
+    with _email_throttle_lock:
+        now = _time.time()
+        # Prune sends older than 1 hour
+        _email_send_times[:] = [t for t in _email_send_times if now - t < 3600]
+
+        if force_digest or (not is_urgent and len(_email_send_times) >= _EMAIL_MAX_PER_HOUR):
+            # Queue for digest instead of sending immediately
+            _email_digest_queue.append({
+                "to": to, "subject": subject, "body": email_body,
+                "from_account": from_account, "event_type": event_type,
+                "timestamp": timestamp,
+            })
+            # Flush digest every 15 minutes
+            if now - _last_digest_flush >= _EMAIL_DIGEST_INTERVAL and _email_digest_queue:
+                _flush_email_digest()
+                _last_digest_flush = now
+            return {
+                "channel": "email",
+                "delivered": False,
+                "queued": True,
+                "reason": "Batched for digest." if force_digest else f"Throttled ({len(_email_send_times)}/{_EMAIL_MAX_PER_HOUR} per hour). Batched for digest.",
+                "queue_size": len(_email_digest_queue),
+                "timestamp": timestamp,
+            }
+        _email_send_times.append(now)
 
-    # Try from_account first, then fall back to env vars
+    # Try from_account first, then _defaults, then fall back to env vars
+    if not from_account:
+        defaults = _load_smtp_account("_defaults")
+        if defaults and defaults.get("from_account"):
+            from_account = defaults["from_account"]
     account_creds = _load_smtp_account(from_account) if from_account else None
 
     if account_creds:
@@ -250,7 +775,7 @@ def send_email(
         smtp_port = int(account_creds.get("port", 587))
         smtp_user = account_creds.get("user", "")
         smtp_pass = account_creds.get("pass", "")
-        smtp_from = from_account
+        smtp_from = account_creds.get("from_alias", from_account)
     else:
         smtp_host = os.environ.get("DELIMIT_SMTP_HOST", "")
         smtp_port = int(os.environ.get("DELIMIT_SMTP_PORT", "587"))
@@ -258,7 +783,12 @@ def send_email(
         smtp_pass = os.environ.get("DELIMIT_SMTP_PASS", "")
         smtp_from = os.environ.get("DELIMIT_SMTP_FROM", "")
 
-    smtp_to = to or os.environ.get("DELIMIT_SMTP_TO", "owner@example.com")
+    # Resolve recipient: explicit > env var > smtp-all.json _defaults
+    smtp_to = to or os.environ.get("DELIMIT_SMTP_TO", "")
+    if not smtp_to:
+        defaults = _load_smtp_account("_defaults")
+        if defaults:
+            smtp_to = defaults.get("to", "")
 
     if not all([smtp_host, smtp_from, smtp_to]):
         record = {
@@ -282,7 +812,8 @@ def send_email(
         }
 
     subj = subject or f"Delimit: {event_type or 'Notification'}"
-    msg = MIMEText(email_body)
+    html_body = _render_html_email(subj, email_body, event_type)
+    msg = MIMEText(html_body, "html")
     msg["Subject"] = subj
     msg["From"] = smtp_from
     msg["To"] = smtp_to
@@ -342,6 +873,149 @@ def send_email(
         }
 
 
+# ═════════════════════════════════════════════════════════════════════
+#  Email Protocol — enforced server-side, model-agnostic
+# ═════════════════════════════════════════════════════════════════════
+# Every email must be self-contained and actionable on mobile.
+# The protocol validates required sections per event_type and rejects
+# or fixes emails that don't meet the standard.
+
+# Subject line MUST start with one of these brackets:
+_VALID_SUBJECT_PREFIXES = (
+    "[APPROVE]", "[ACTION]", "[INFO]", "[ALERT]", "[DIGEST]",
+    "[URGENT]", "[OUTREACH]", "[DEPLOY]", "[GATE]",
+)
+
+# Required sections per event_type. Each is a (header, description) tuple.
+_EMAIL_PROTOCOL: Dict[str, List[tuple]] = {
+    "social_draft": [
+        ("THREAD CONTEXT", "subreddit/platform, post topic, engagement stats"),
+        ("DRAFT", "the full draft text, not just an ID"),
+        ("TO APPROVE", "reply instructions with draft_id"),
+    ],
+    "outreach": [
+        ("TARGETS FOUND", "list with platform, title/snippet, URL"),
+        ("DRAFTS", "full draft text for each, with draft_id"),
+        ("TO APPROVE", "reply instructions"),
+    ],
+    "deploy": [
+        ("WHAT CHANGED", "summary of changes being deployed"),
+        ("GATES PASSED", "test, security, lint results"),
+        ("TO APPROVE", "reply instructions or auto-proceed note"),
+    ],
+    "gate_failure": [
+        ("WHAT FAILED", "which gate and why"),
+        ("IMPACT", "what is blocked"),
+        ("TO FIX", "next steps"),
+    ],
+    "digest": [
+        ("COMPLETED", "what was done since last digest"),
+        ("PENDING YOUR ACTION", "items needing founder response"),
+    ],
+}
+
+
+def _load_drafts_by_ids(draft_ids: list) -> list:
+    """Load draft entries from social_drafts.jsonl matching the given IDs."""
+    drafts_file = Path.home() / ".delimit" / "social_drafts.jsonl"
+    if not drafts_file.exists():
+        return []
+    results = []
+    id_set = set(draft_ids)
+    try:
+        for line in drafts_file.read_text().splitlines():
+            if not line.strip():
+                continue
+            try:
+                d = json.loads(line)
+                if d.get("draft_id") in id_set and d.get("status") == "pending":
+                    results.append(d)
+            except (json.JSONDecodeError, ValueError):
+                continue
+    except Exception:
+        pass
+    return results
+
+
+def _enforce_email_protocol(subject: str, message: str, event_type: str) -> tuple:
+    """Validate and fix email against the protocol. Returns (subject, message, warnings)."""
+    warnings = []
+
+    # 1. Subject must have a valid prefix bracket
+    if not any(subject.startswith(p) for p in _VALID_SUBJECT_PREFIXES):
+        # Try to infer from event_type
+        prefix_map = {
+            "social_draft": "[APPROVE]",
+            "outreach": "[OUTREACH]",
+            "deploy": "[DEPLOY]",
+            "gate_failure": "[ALERT]",
+            "digest": "[DIGEST]",
+            "info": "[INFO]",
+        }
+        prefix = prefix_map.get(event_type, "[INFO]")
+        subject = f"{prefix} {subject}"
+        warnings.append(f"Subject prefix added: {prefix}")
+
+    # 2. Check required sections for this event_type
+    required = _EMAIL_PROTOCOL.get(event_type, [])
+    msg_upper = message.upper()
+    missing = []
+    for header, desc in required:
+        # Check if the section header appears (case-insensitive, with or without colon)
+        if header.upper() not in msg_upper:
+            missing.append(f"{header} ({desc})")
+
+    if missing:
+        # Append a protocol warning to the email body so the founder sees what's missing
+        message += "\n\n" + "=" * 40
+        message += "\nPROTOCOL WARNING — Missing required sections:"
+        for m in missing:
+            message += f"\n  - {m}"
+        message += "\n\nThis email may not be fully actionable. The sending model"
+        message += "\nskipped required context. Check drafts via delimit_social_approve."
+        warnings.append(f"Missing sections: {', '.join(m.split(' (')[0] for m in missing)}")
+
+    # 3. Outreach/social_draft emails — auto-inject full draft text from social_drafts.jsonl
+    if event_type in ("social_draft", "outreach"):
+        import re
+        draft_ids = re.findall(r'[0-9a-f]{12}', message)
+        if draft_ids:
+            drafts = _load_drafts_by_ids(draft_ids)
+            if drafts:
+                message += "\n\n" + "=" * 40
+                message += "\nCOPY-READY DRAFTS"
+                message += "\n" + "=" * 40
+                for d in drafts:
+                    did = d.get("draft_id", "")
+                    text = d.get("text", "")
+                    platform = d.get("platform", "")
+                    ctx = d.get("context", "")
+                    thread_url = d.get("thread_url", "")
+                    reply_to_id = d.get("reply_to_id", "")
+                    # Try to extract URL from context if thread_url is empty
+                    if not thread_url and ctx:
+                        url_match = re.search(r'https?://[^\s]+', ctx)
+                        if url_match:
+                            thread_url = url_match.group(0)
+                    message += f"\n\n--- Draft {did} ({platform}) ---"
+                    message += f"\nWHERE: {platform}"
+                    where_link = thread_url or (f"https://x.com/i/status/{reply_to_id}" if reply_to_id else "")
+                    if where_link:
+                        message += f"\nLINK: {where_link}"
+                    if ctx:
+                        message += f"\nWHY: {ctx}"
+                    message += f"\nWHAT:\nManual Post Text\n{text}"
+                    message += f"\n\nTo approve: reply \"approve {did}\""
+                message += "\n\n" + "=" * 40
+                warnings.append(f"Auto-injected {len(drafts)} draft texts from social_drafts.jsonl")
+
+    # 4. Always append the standard footer
+    if "delimit.ai" not in message.lower() and "Delimit" not in message:
+        message += "\n\n---\nSent by Delimit governance layer"
+
+    return subject, message, warnings
+
+
 def send_notification(
     channel: str = "webhook",
     message: str = "",
@@ -355,20 +1029,30 @@ def send_notification(
     if not message:
         return {"error": "message is required"}
 
+    # Enforce email protocol for all email notifications
+    protocol_warnings = []
+    if channel == "email":
+        subject, message, protocol_warnings = _enforce_email_protocol(subject, message, event_type)
+
     if channel == "webhook":
         return send_webhook(webhook_url, message, event_type)
     elif channel == "slack":
         return send_slack(webhook_url, message, event_type)
     elif channel == "email":
-        return send_email(
+        result = send_email(
             to=to,
             subject=subject,
             message=message,
             from_account=from_account,
             event_type=event_type,
         )
+        if protocol_warnings:
+            result["protocol_warnings"] = protocol_warnings
+        return result
+    elif channel == "telegram":
+        return send_telegram(message=message, event_type=event_type)
     else:
-        return {"error": f"Unknown channel: {channel}. Supported: webhook, slack, email"}
+        return {"error": f"Unknown channel: {channel}. Supported: webhook, slack, email, telegram"}
 
 
 # ═════════════════════════════════════════════════════════════════════
@@ -786,6 +1470,9 @@ def poll_inbox(
     """
     if not smtp_pass:
         smtp_pass = os.environ.get("DELIMIT_SMTP_PASS", "")
+    if not smtp_pass and IMAP_USER:
+        account = _load_smtp_account(IMAP_USER)
+        smtp_pass = str((account or {}).get("pass") or (account or {}).get("password") or "")
     if not smtp_pass:
         return {"error": "IMAP password required. Set DELIMIT_SMTP_PASS or pass smtp_pass."}