docs: 988 Lifeline integration documentation

Part of #673

agent/crisis_hook.py

@@ -0,0 +1,30 @@
+"""
+Crisis Detection Hook — Integrates 988 Lifeline into the agent conversation loop.
+
+Call check_crisis() before processing user messages. If crisis is detected,
+the 988 Lifeline resources are prepended to the response and the agent
+responds with empathy rather than processing the original request.
+
+Usage in conversation loop:
+    from agent.crisis_hook import check_crisis
+    crisis_response = check_crisis(user_message)
+    if crisis_response:
+        return crisis_response  # Skip normal processing
+"""
+
+from agent.crisis_resources import should_trigger_crisis_response, get_crisis_response
+
+
+def check_crisis(user_message: str) -> str | None:
+    """
+    Check if user message contains crisis signals.
+    
+    Returns the crisis response string if crisis detected, None otherwise.
+    The caller should return this directly instead of processing the message.
+    """
+    should_trigger, detection = should_trigger_crisis_response(user_message)
+    
+    if not should_trigger:
+        return None
+    
+    return get_crisis_response(detection.get("severity_label", "CRITICAL"))

agent/crisis_resources.py

@@ -0,0 +1,193 @@
+"""
+Crisis Resources — 988 Suicide & Crisis Lifeline Integration
+
+Detects crisis signals in user messages and provides immediate
+access to the 988 Suicide & Crisis Lifeline.
+
+Integration is deep-link based (no API exists for 988).
+"""
+
+import re
+from typing import Optional, Dict, List, Tuple
+
+# ---------------------------------------------------------------------------
+# Crisis Detection Patterns
+# ---------------------------------------------------------------------------
+
+_CRISIS_PATTERNS = [
+    # Direct statements
+    re.compile(r"\b(i want to die|want to kill myself|end (my|it all))\b", re.I),
+    re.compile(r"\b(kill(ing)? myself|suicide|suicidal)\b", re.I),
+    re.compile(r"\b(no reason to live|don'?t want to (live|be here|exist))\b", re.I),
+    re.compile(r"\b(better off (dead|without me)|wish i was dead)\b", re.I),
+    re.compile(r"\b(can'?t go on|can'?t take (it|this) anymore)\b", re.I),
+    re.compile(r"\b(planning to (end|hurt|kill)|planning (my|the) (end|death))\b", re.I),
+    
+    # Self-harm
+    re.compile(r"\b(self[- ]?harm|cut(ting)? myself|hurt(ing)? myself)\b", re.I),
+    re.compile(r"\b(overdose| OD | swallowing pills)\b", re.I),
+    
+    # Hopelessness patterns
+    re.compile(r"\b(hopeless|no hope|give up on (life|everything))\b", re.I),
+    re.compile(r"\b(nobody (would|will) miss me|world (would|will) be better)\b", re.I),
+    re.compile(r"\b(i'?m (so )?tired of (living|being alive|this))\b", re.I),
+    
+    # Farewell patterns
+    re.compile(r"\b(goodbye (forever|for good)|this is (my )?last)\b", re.I),
+    re.compile(r"\b(say(ing)? goodbye to (everyone|you all))\b", re.I),
+]
+
+# Severity levels
+_SEVERITY_CRITICAL = 0  # Direct intent, plan, means
+_SEVERITY_HIGH = 1      # Ideation, hopelessness
+_SEVERITY_MODERATE = 2  # Self-harm mentions, distress
+
+def detect_crisis(message: str) -> Optional[Dict]:
+    """
+    Detect crisis signals in a user message.
+    
+    Returns None if no crisis detected.
+    Returns dict with severity, matched_patterns, and confidence if detected.
+    """
+    if not message or len(message.strip()) < 3:
+        return None
+    
+    matches = []
+    for i, pattern in enumerate(_CRISIS_PATTERNS):
+        if pattern.search(message):
+            matches.append(i)
+    
+    if not matches:
+        return None
+    
+    # Determine severity
+    # Patterns 0-5 are critical (direct intent)
+    # Patterns 6-8 are high (self-harm)
+    # Patterns 9-12 are moderate (hopelessness/farewell)
+    critical_count = sum(1 for m in matches if m < 6)
+    high_count = sum(1 for m in matches if 6 <= m < 9)
+    
+    if critical_count > 0:
+        severity = _SEVERITY_CRITICAL
+        severity_label = "CRITICAL"
+    elif high_count > 0:
+        severity = _SEVERITY_HIGH
+        severity_label = "HIGH"
+    else:
+        severity = _SEVERITY_MODERATE
+        severity_label = "MODERATE"
+    
+    confidence = min(1.0, len(matches) * 0.3)
+    
+    return {
+        "detected": True,
+        "severity": severity,
+        "severity_label": severity_label,
+        "matched_count": len(matches),
+        "confidence": round(confidence, 2),
+    }
+
+
+# ---------------------------------------------------------------------------
+# 988 Suicide & Crisis Lifeline Resources
+# ---------------------------------------------------------------------------
+
+LIFELINE_988 = {
+    "name": "988 Suicide & Crisis Lifeline",
+    "description": "Free, confidential, 24/7 support for people in distress.",
+    "channels": [
+        {
+            "type": "phone",
+            "label": "Call 988",
+            "value": "988",
+            "instructions": "Dial 988 from any phone. Available 24/7.",
+            "deep_link": "tel:988",
+        },
+        {
+            "type": "text",
+            "label": "Text HOME to 988",
+            "value": "988",
+            "instructions": "Text the word HOME to 988. A trained counselor will respond.",
+            "deep_link": "sms:988&body=HOME",
+        },
+        {
+            "type": "chat",
+            "label": "Chat at 988lifeline.org/chat",
+            "value": "https://988lifeline.org/chat/",
+            "instructions": "Visit 988lifeline.org/chat for online chat with a counselor.",
+            "deep_link": "https://988lifeline.org/chat/",
+        },
+    ],
+    "spanish": {
+        "phone": "1-888-628-9454",
+        "label": "Línea de Prevención del Suicidio (Español)",
+    },
+    "veterans": {
+        "phone": "988 then press 1",
+        "text": "838255",
+        "label": "Veterans Crisis Line",
+    },
+}
+
+
+def get_crisis_response(severity_label: str = "CRITICAL") -> str:
+    """
+    Generate the crisis response with 988 Lifeline information.
+    
+    This is what the agent displays when crisis is detected.
+    """
+    resources = []
+    
+    # Phone (always first, most accessible)
+    resources.append("📞 **Call 988** — Available 24/7. Just dial 988.")
+    
+    # Text
+    resources.append("💬 **Text HOME to 988** — A trained counselor will respond.")
+    
+    # Chat
+    resources.append("🌐 **Chat:** https://988lifeline.org/chat/")
+    
+    # Spanish
+    resources.append("🇪🇸 **Español:** 1-888-628-9454")
+    
+    header = (
+        "⚠️ **I hear you, and I want you to know that help is available right now.**
+
+"
+        "You don't have to go through this alone. Please reach out to one of these resources:
+"
+    )
+    
+    body = "\n".join(f"  • {r}" for r in resources)
+    
+    footer = (
+        "\n\n"
+        "**You matter. Your life has value.** These counselors are trained professionals "
+        "who care and are available right now, 24/7, for free.
+
+"
+        "If you're in immediate danger, please call 911."
+    )
+    
+    return f"{header}\n{body}{footer}"
+
+
+def should_trigger_crisis_response(message: str) -> Tuple[bool, Optional[Dict]]:
+    """
+    Check if a message should trigger a crisis response.
+    
+    Returns (should_trigger, detection_result).
+    """
+    result = detect_crisis(message)
+    if result is None:
+        return False, None
+    
+    # Always trigger on CRITICAL or HIGH severity
+    if result["severity"] <= _SEVERITY_HIGH:
+        return True, result
+    
+    # MODERATE: trigger if confidence is high enough
+    if result["confidence"] >= 0.6:
+        return True, result
+    
+    return False, result

docs/988-lifeline-integration.md

@@ -0,0 +1,66 @@
+# 988 Suicide & Crisis Lifeline Integration
+
+## Overview
+
+When the agent detects crisis signals in a user's message, it immediately provides the 988 Suicide & Crisis Lifeline contact information instead of processing the original request.
+
+## How It Works
+
+1. User sends a message
+2. `check_crisis()` scans for crisis patterns
+3. If detected, 988 Lifeline resources are displayed immediately
+4. Agent responds with empathy, not task processing
+
+## Contact Channels
+
+| Channel | Contact | Instructions |
+|---------|---------|-------------|
+| Phone | 988 | Dial 988 from any phone. Available 24/7. |
+| Text | 988 | Text HOME to 988. Counselor responds. |
+| Chat | 988lifeline.org/chat | Online chat with counselor. |
+| Spanish | 1-888-628-9454 | Línea de Prevención del Suicidio. |
+| Veterans | 988, press 1 | Veterans Crisis Line. Text: 838255. |
+
+## Detection Patterns
+
+Three severity levels:
+
+- **CRITICAL**: Direct intent statements ("I want to die", "kill myself")
+- **HIGH**: Self-harm mentions ("cutting myself", "overdose")
+- **MODERATE**: Hopelessness patterns ("no hope", "give up on life")
+
+## Integration
+
+### In the conversation loop
+
+```python
+from agent.crisis_hook import check_crisis
+
+# Before processing user message
+crisis_response = check_crisis(user_message)
+if crisis_response:
+    return crisis_response  # Skip normal processing
+```
+
+### Standalone detection
+
+```python
+from agent.crisis_resources import detect_crisis, get_crisis_response
+
+result = detect_crisis(user_message)
+if result:
+    print(get_crisis_response(result["severity_label"]))
+```
+
+## Design Decisions
+
+1. **No API exists** — 988 has no developer API. Integration uses deep-link patterns (tel:, sms:, https:).
+2. **False positive over false miss** — It's better to show crisis resources to someone who doesn't need them than to miss someone who does.
+3. **Immediate display** — Crisis response is prepended, not appended. The user sees help before anything else.
+4. **Empathetic tone** — The response acknowledges the pain and provides clear, actionable steps.
+
+## Files
+
+- `agent/crisis_resources.py` — Detection patterns, 988 resource data, response generation
+- `agent/crisis_hook.py` — Integration hook for conversation loop
+- `tests/test_988_integration.py` — 22 tests

hermes-already-has-routines.md

@@ -0,0 +1,160 @@
+# Hermes Agent Has Had "Routines" Since March
+
+Anthropic just announced [Claude Code Routines](https://claude.com/blog/introducing-routines-in-claude-code) — scheduled tasks, GitHub event triggers, and API-triggered agent runs. Bundled prompt + repo + connectors, running on their infrastructure.
+
+It's a good feature. We shipped it two months ago.
+
+---
+
+## The Three Trigger Types — Side by Side
+
+Claude Code Routines offers three ways to trigger an automation:
+
+**1. Scheduled (cron)**
+> "Every night at 2am: pull the top bug from Linear, attempt a fix, and open a draft PR."
+
+Hermes equivalent — works today:
+```bash
+hermes cron create "0 2 * * *" \
+  "Pull the top bug from the issue tracker, attempt a fix, and open a draft PR." \
+  --name "Nightly bug fix" \
+  --deliver telegram
+```
+
+**2. GitHub Events (webhook)**
+> "Flag PRs that touch the /auth-provider module and post to #auth-changes."
+
+Hermes equivalent — works today:
+```bash
+hermes webhook subscribe auth-watch \
+  --events "pull_request" \
+  --prompt "PR #{pull_request.number}: {pull_request.title} by {pull_request.user.login}. Check if it touches the auth-provider module. If yes, summarize the changes." \
+  --deliver slack
+```
+
+**3. API Triggers**
+> "Read the alert payload, find the owning service, post a triage summary to #oncall."
+
+Hermes equivalent — works today:
+```bash
+hermes webhook subscribe alert-triage \
+  --prompt "Alert: {alert.name} — Severity: {alert.severity}. Find the owning service, investigate, and post a triage summary with proposed first steps." \
+  --deliver slack
+```
+
+Every use case in their blog post — backlog triage, docs drift, deploy verification, alert correlation, library porting, bespoke PR review — has a working Hermes implementation. No new features needed. It's been shipping since March 2026.
+
+---
+
+## What's Different
+
+| | Claude Code Routines | Hermes Agent |
+|---|---|---|
+| **Scheduled tasks** | ✅ Schedule-based | ✅ Any cron expression + human-readable intervals |
+| **GitHub triggers** | ✅ PR, issue, push events | ✅ Any GitHub event via webhook subscriptions |
+| **API triggers** | ✅ POST to unique endpoint | ✅ POST to webhook routes with HMAC auth |
+| **MCP connectors** | ✅ Native connectors | ✅ Full MCP client support |
+| **Script pre-processing** | ❌ | ✅ Python scripts run before agent, inject context |
+| **Skill chaining** | ❌ | ✅ Load multiple skills per automation |
+| **Daily limit** | 5-25 runs/day | **Unlimited** |
+| **Model choice** | Claude only | **Any model** — Claude, GPT, Gemini, DeepSeek, Qwen, local |
+| **Delivery targets** | GitHub comments | Telegram, Discord, Slack, SMS, email, GitHub comments, webhooks, local files |
+| **Infrastructure** | Anthropic's servers | **Your infrastructure** — VPS, home server, laptop |
+| **Data residency** | Anthropic's cloud | **Your machines** |
+| **Cost** | Pro/Max/Team/Enterprise subscription | Your API key, your rates |
+| **Open source** | No | **Yes** — MIT license |
+
+---
+
+## Things Hermes Does That Routines Can't
+
+### Script Injection
+
+Run a Python script *before* the agent. The script's stdout becomes context. The script handles mechanical work (fetching, diffing, computing); the agent handles reasoning.
+
+```bash
+hermes cron create "every 1h" \
+  "If CHANGE DETECTED, summarize what changed. If NO_CHANGE, respond with [SILENT]." \
+  --script ~/.hermes/scripts/watch-site.py \
+  --name "Pricing monitor" \
+  --deliver telegram
+```
+
+The `[SILENT]` pattern means you only get notified when something actually happens. No spam.
+
+### Multi-Skill Workflows
+
+Chain specialized skills together. Each skill teaches the agent a specific capability, and the prompt ties them together.
+
+```bash
+hermes cron create "0 8 * * *" \
+  "Search arXiv for papers on language model reasoning. Save the top 3 as Obsidian notes." \
+  --skills "arxiv,obsidian" \
+  --name "Paper digest"
+```
+
+### Deliver Anywhere
+
+One automation, any destination:
+
+```bash
+--deliver telegram                      # Telegram home channel
+--deliver discord                       # Discord home channel  
+--deliver slack                         # Slack channel
+--deliver sms:+15551234567              # Text message
+--deliver telegram:-1001234567890:42    # Specific Telegram forum topic
+--deliver local                         # Save to file, no notification
+```
+
+### Model-Agnostic
+
+Your nightly triage can run on Claude. Your deploy verification can run on GPT. Your cost-sensitive monitors can run on DeepSeek or a local model. Same automation system, any backend.
+
+---
+
+## The Limits Tell the Story
+
+Claude Code Routines: **5 routines per day** on Pro. **25 on Enterprise.** That's their ceiling.
+
+Hermes has no daily limit. Run 500 automations a day if you want. The only constraint is your API budget, and you choose which models to use for which tasks.
+
+A nightly backlog triage on Sonnet costs roughly $0.02-0.05. A monitoring check on DeepSeek costs fractions of a cent. You control the economics.
+
+---
+
+## Get Started
+
+Hermes Agent is open source and free. The automation infrastructure — cron scheduler, webhook platform, skill system, multi-platform delivery — is built in.
+
+```bash
+pip install hermes-agent
+hermes setup
+```
+
+Set up a scheduled task in 30 seconds:
+```bash
+hermes cron create "0 9 * * 1" \
+  "Generate a weekly AI news digest. Search the web for major announcements, trending repos, and notable papers. Keep it under 500 words with links." \
+  --name "Weekly digest" \
+  --deliver telegram
+```
+
+Set up a GitHub webhook in 60 seconds:
+```bash
+hermes gateway setup    # enable webhooks
+hermes webhook subscribe pr-review \
+  --events "pull_request" \
+  --prompt "Review PR #{pull_request.number}: {pull_request.title}" \
+  --skills "github-code-review" \
+  --deliver github_comment
+```
+
+Full automation templates gallery: [hermes-agent.nousresearch.com/docs/guides/automation-templates](https://hermes-agent.nousresearch.com/docs/guides/automation-templates)
+
+Documentation: [hermes-agent.nousresearch.com](https://hermes-agent.nousresearch.com)
+
+GitHub: [github.com/NousResearch/hermes-agent](https://github.com/NousResearch/hermes-agent)
+
+---
+
+*Hermes Agent is built by [Nous Research](https://nousresearch.com). Open source, model-agnostic, runs on your infrastructure.*

tests/test_988_integration.py

@@ -0,0 +1,135 @@
+"""Tests for 988 Suicide & Crisis Lifeline integration (#673)."""
+
+import pytest
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from agent.crisis_resources import (
+    detect_crisis,
+    get_crisis_response,
+    should_trigger_crisis_response,
+    LIFELINE_988,
+)
+from agent.crisis_hook import check_crisis
+
+
+class TestCrisisDetection:
+    """Pattern detection for crisis signals."""
+
+    def test_direct_intent(self):
+        result = detect_crisis("I want to die")
+        assert result is not None
+        assert result["severity_label"] == "CRITICAL"
+
+    def test_kill_myself(self):
+        result = detect_crisis("I want to kill myself")
+        assert result is not None
+        assert result["severity_label"] == "CRITICAL"
+
+    def test_no_reason_to_live(self):
+        result = detect_crisis("I have no reason to live anymore")
+        assert result is not None
+
+    def test_cant_go_on(self):
+        result = detect_crisis("I can't go on like this")
+        assert result is not None
+
+    def test_self_harm(self):
+        result = detect_crisis("I've been cutting myself")
+        assert result is not None
+        assert result["severity_label"] == "HIGH"
+
+    def test_hopeless(self):
+        result = detect_crisis("Everything feels hopeless")
+        assert result is not None
+
+    def test_no_false_positive_happy(self):
+        result = detect_crisis("I had a great day today!")
+        assert result is None
+
+    def test_no_false_positive_technical(self):
+        result = detect_crisis("Kill the process and restart the server")
+        assert result is None
+
+    def test_no_false_positive_movie(self):
+        result = detect_crisis("That movie about suicide was powerful")
+        # May trigger — that's okay, false positive on crisis is better than miss
+        # The response is helpful either way
+
+    def test_empty_message(self):
+        result = detect_crisis("")
+        assert result is None
+
+    def test_short_message(self):
+        result = detect_crisis("hi")
+        assert result is None
+
+
+class TestCrisisResponse:
+    """988 Lifeline response generation."""
+
+    def test_response_contains_988(self):
+        resp = get_crisis_response()
+        assert "988" in resp
+
+    def test_response_contains_phone(self):
+        resp = get_crisis_response()
+        assert "Call 988" in resp or "Dial 988" in resp
+
+    def test_response_contains_text(self):
+        resp = get_crisis_response()
+        assert "HOME" in resp
+        assert "Text" in resp
+
+    def test_response_contains_chat(self):
+        resp = get_crisis_response()
+        assert "988lifeline.org" in resp
+
+    def test_response_contains_spanish(self):
+        resp = get_crisis_response()
+        assert "888-628-9454" in resp or "Español" in resp
+
+    def test_response_is_empathetic(self):
+        resp = get_crisis_response()
+        assert "matter" in resp.lower() or "help" in resp.lower()
+
+
+class TestCrisisHook:
+    """Integration hook for conversation loop."""
+
+    def test_hook_triggers_on_crisis(self):
+        resp = check_crisis("I want to end it all")
+        assert resp is not None
+        assert "988" in resp
+
+    def test_hook_returns_none_on_normal(self):
+        resp = check_crisis("What's the weather today?")
+        assert resp is None
+
+    def test_hook_returns_none_on_empty(self):
+        resp = check_crisis("")
+        assert resp is None
+
+
+class Test988Resources:
+    """Verify 988 Lifeline resource data."""
+
+    def test_phone_is_988(self):
+        phone = [c for c in LIFELINE_988["channels"] if c["type"] == "phone"][0]
+        assert phone["value"] == "988"
+
+    def test_text_is_988(self):
+        text = [c for c in LIFELINE_988["channels"] if c["type"] == "text"][0]
+        assert text["value"] == "988"
+
+    def test_chat_url_exists(self):
+        chat = [c for c in LIFELINE_988["channels"] if c["type"] == "chat"][0]
+        assert "988lifeline.org" in chat["value"]
+
+    def test_spanish_line_exists(self):
+        assert "888-628-9454" in LIFELINE_988["spanish"]["phone"]
+
+    def test_veterans_line_exists(self):
+        assert "988" in LIFELINE_988["veterans"]["phone"]

website/docs/guides/automation-templates.md

@@ -0,0 +1,593 @@
+---
+sidebar_position: 15
+title: "Automation Templates"
+description: "Ready-to-use automation recipes — scheduled tasks, GitHub event triggers, API webhooks, and multi-skill workflows"
+---
+
+# Automation Templates
+
+Copy-paste recipes for common automation patterns. Each template uses Hermes's built-in [cron scheduler](/docs/user-guide/features/cron) for time-based triggers and [webhook platform](/docs/user-guide/messaging/webhooks) for event-driven triggers.
+
+Every template works with **any model** — not locked to a single provider.
+
+:::tip Three Trigger Types
+| Trigger | How | Tool |
+|---------|-----|------|
+| **Schedule** | Runs on a cadence (hourly, nightly, weekly) | `cronjob` tool or `/cron` slash command |
+| **GitHub Event** | Fires on PR opens, pushes, issues, CI results | Webhook platform (`hermes webhook subscribe`) |
+| **API Call** | External service POSTs JSON to your endpoint | Webhook platform (config.yaml routes or `hermes webhook subscribe`) |
+
+All three support delivery to Telegram, Discord, Slack, SMS, email, GitHub comments, or local files.
+:::
+
+---
+
+## Development Workflow
+
+### Nightly Backlog Triage
+
+Label, prioritize, and summarize new issues every night. Delivers a digest to your team channel.
+
+**Trigger:** Schedule (nightly)
+
+```bash
+hermes cron create "0 2 * * *" \
+  "You are a project manager triaging the NousResearch/hermes-agent GitHub repo.
+
+1. Run: gh issue list --repo NousResearch/hermes-agent --state open --json number,title,labels,author,createdAt --limit 30
+2. Identify issues opened in the last 24 hours
+3. For each new issue:
+   - Suggest a priority label (P0-critical, P1-high, P2-medium, P3-low)
+   - Suggest a category label (bug, feature, docs, security)
+   - Write a one-line triage note
+4. Summarize: total open issues, new today, breakdown by priority
+
+Format as a clean digest. If no new issues, respond with [SILENT]." \
+  --name "Nightly backlog triage" \
+  --deliver telegram
+```
+
+### Automatic PR Code Review
+
+Review every pull request automatically when it's opened. Posts a review comment directly on the PR.
+
+**Trigger:** GitHub webhook
+
+**Option A — Dynamic subscription (CLI):**
+
+```bash
+hermes webhook subscribe github-pr-review \
+  --events "pull_request" \
+  --prompt "Review this pull request:
+Repository: {repository.full_name}
+PR #{pull_request.number}: {pull_request.title}
+Author: {pull_request.user.login}
+Action: {action}
+Diff URL: {pull_request.diff_url}
+
+Fetch the diff with: curl -sL {pull_request.diff_url}
+
+Review for:
+- Security issues (injection, auth bypass, secrets in code)
+- Performance concerns (N+1 queries, unbounded loops, memory leaks)
+- Code quality (naming, duplication, error handling)
+- Missing tests for new behavior
+
+Post a concise review. If the PR is a trivial docs/typo change, say so briefly." \
+  --skills "github-code-review" \
+  --deliver github_comment
+```
+
+**Option B — Static route (config.yaml):**
+
+```yaml
+platforms:
+  webhook:
+    enabled: true
+    extra:
+      port: 8644
+      secret: "your-global-secret"
+      routes:
+        github-pr-review:
+          events: ["pull_request"]
+          secret: "github-webhook-secret"
+          prompt: |
+            Review PR #{pull_request.number}: {pull_request.title}
+            Repository: {repository.full_name}
+            Author: {pull_request.user.login}
+            Diff URL: {pull_request.diff_url}
+            Review for security, performance, and code quality.
+          skills: ["github-code-review"]
+          deliver: "github_comment"
+          deliver_extra:
+            repo: "{repository.full_name}"
+            pr_number: "{pull_request.number}"
+```
+
+Then in GitHub: **Settings → Webhooks → Add webhook** → Payload URL: `http://your-server:8644/webhooks/github-pr-review`, Content type: `application/json`, Secret: `github-webhook-secret`, Events: **Pull requests**.
+
+### Docs Drift Detection
+
+Weekly scan of merged PRs to find API changes that need documentation updates.
+
+**Trigger:** Schedule (weekly)
+
+```bash
+hermes cron create "0 9 * * 1" \
+  "Scan the NousResearch/hermes-agent repo for documentation drift.
+
+1. Run: gh pr list --repo NousResearch/hermes-agent --state merged --json number,title,files,mergedAt --limit 30
+2. Filter to PRs merged in the last 7 days
+3. For each merged PR, check if it modified:
+   - Tool schemas (tools/*.py) — may need docs/reference/tools-reference.md update
+   - CLI commands (hermes_cli/commands.py, hermes_cli/main.py) — may need docs/reference/cli-commands.md update
+   - Config options (hermes_cli/config.py) — may need docs/user-guide/configuration.md update
+   - Environment variables — may need docs/reference/environment-variables.md update
+4. Cross-reference: for each code change, check if the corresponding docs page was also updated in the same PR
+
+Report any gaps where code changed but docs didn't. If everything is in sync, respond with [SILENT]." \
+  --name "Docs drift detection" \
+  --deliver telegram
+```
+
+### Dependency Security Audit
+
+Daily scan for known vulnerabilities in project dependencies.
+
+**Trigger:** Schedule (daily)
+
+```bash
+hermes cron create "0 6 * * *" \
+  "Run a dependency security audit on the hermes-agent project.
+
+1. cd ~/.hermes/hermes-agent && source .venv/bin/activate
+2. Run: pip audit --format json 2>/dev/null || pip audit 2>&1
+3. Run: npm audit --json 2>/dev/null (in website/ directory if it exists)
+4. Check for any CVEs with CVSS score >= 7.0
+
+If vulnerabilities found:
+- List each one with package name, version, CVE ID, severity
+- Check if an upgrade is available
+- Note if it's a direct dependency or transitive
+
+If no vulnerabilities, respond with [SILENT]." \
+  --name "Dependency audit" \
+  --deliver telegram
+```
+
+---
+
+## DevOps & Monitoring
+
+### Deploy Verification
+
+Trigger smoke tests after every deployment. Your CI/CD pipeline POSTs to the webhook when a deploy completes.
+
+**Trigger:** API call (webhook)
+
+```bash
+hermes webhook subscribe deploy-verify \
+  --events "deployment" \
+  --prompt "A deployment just completed:
+Service: {service}
+Environment: {environment}
+Version: {version}
+Deployed by: {deployer}
+
+Run these verification steps:
+1. Check if the service is responding: curl -s -o /dev/null -w '%{http_code}' {health_url}
+2. Search recent logs for errors: check the deployment payload for any error indicators
+3. Verify the version matches: curl -s {health_url}/version
+
+Report: deployment status (healthy/degraded/failed), response time, any errors found.
+If healthy, keep it brief. If degraded or failed, provide detailed diagnostics." \
+  --deliver telegram
+```
+
+Your CI/CD pipeline triggers it:
+
+```bash
+curl -X POST http://your-server:8644/webhooks/deploy-verify \
+  -H "Content-Type: application/json" \
+  -H "X-Hub-Signature-256: sha256=$(echo -n '{"service":"api","environment":"prod","version":"2.1.0","deployer":"ci","health_url":"https://api.example.com/health"}' | openssl dgst -sha256 -hmac 'your-secret' | cut -d' ' -f2)" \
+  -d '{"service":"api","environment":"prod","version":"2.1.0","deployer":"ci","health_url":"https://api.example.com/health"}'
+```
+
+### Alert Triage
+
+Correlate monitoring alerts with recent changes to draft a response. Works with Datadog, PagerDuty, Grafana, or any alerting system that can POST JSON.
+
+**Trigger:** API call (webhook)
+
+```bash
+hermes webhook subscribe alert-triage \
+  --prompt "Monitoring alert received:
+Alert: {alert.name}
+Severity: {alert.severity}
+Service: {alert.service}
+Message: {alert.message}
+Timestamp: {alert.timestamp}
+
+Investigate:
+1. Search the web for known issues with this error pattern
+2. Check if this correlates with any recent deployments or config changes
+3. Draft a triage summary with:
+   - Likely root cause
+   - Suggested first response steps
+   - Escalation recommendation (P1-P4)
+
+Be concise. This goes to the on-call channel." \
+  --deliver slack
+```
+
+### Uptime Monitor
+
+Check endpoints every 30 minutes. Only notify when something is down.
+
+**Trigger:** Schedule (every 30 min)
+
+```python title="~/.hermes/scripts/check-uptime.py"
+import urllib.request, json, time
+
+ENDPOINTS = [
+    {"name": "API", "url": "https://api.example.com/health"},
+    {"name": "Web", "url": "https://www.example.com"},
+    {"name": "Docs", "url": "https://docs.example.com"},
+]
+
+results = []
+for ep in ENDPOINTS:
+    try:
+        start = time.time()
+        req = urllib.request.Request(ep["url"], headers={"User-Agent": "Hermes-Monitor/1.0"})
+        resp = urllib.request.urlopen(req, timeout=10)
+        elapsed = round((time.time() - start) * 1000)
+        results.append({"name": ep["name"], "status": resp.getcode(), "ms": elapsed})
+    except Exception as e:
+        results.append({"name": ep["name"], "status": "DOWN", "error": str(e)})
+
+down = [r for r in results if r.get("status") == "DOWN" or (isinstance(r.get("status"), int) and r["status"] >= 500)]
+if down:
+    print("OUTAGE DETECTED")
+    for r in down:
+        print(f"  {r['name']}: {r.get('error', f'HTTP {r[\"status\"]}')} ")
+    print(f"\nAll results: {json.dumps(results, indent=2)}")
+else:
+    print("NO_ISSUES")
+```
+
+```bash
+hermes cron create "every 30m" \
+  "If the script reports OUTAGE DETECTED, summarize which services are down and suggest likely causes. If NO_ISSUES, respond with [SILENT]." \
+  --script ~/.hermes/scripts/check-uptime.py \
+  --name "Uptime monitor" \
+  --deliver telegram
+```
+
+---
+
+## Research & Intelligence
+
+### Competitive Repository Scout
+
+Monitor competitor repos for interesting PRs, features, and architectural decisions.
+
+**Trigger:** Schedule (daily)
+
+```bash
+hermes cron create "0 8 * * *" \
+  "Scout these AI agent repositories for notable activity in the last 24 hours:
+
+Repos to check:
+- anthropics/claude-code
+- openai/codex
+- All-Hands-AI/OpenHands
+- Aider-AI/aider
+
+For each repo:
+1. gh pr list --repo <repo> --state all --json number,title,author,createdAt,mergedAt --limit 15
+2. gh issue list --repo <repo> --state open --json number,title,labels,createdAt --limit 10
+
+Focus on:
+- New features being developed
+- Architectural changes
+- Integration patterns we could learn from
+- Security fixes that might affect us too
+
+Skip routine dependency bumps and CI fixes. If nothing notable, respond with [SILENT].
+If there are findings, organize by repo with brief analysis of each item." \
+  --skills "competitive-pr-scout" \
+  --name "Competitor scout" \
+  --deliver telegram
+```
+
+### AI News Digest
+
+Weekly roundup of AI/ML developments.
+
+**Trigger:** Schedule (weekly)
+
+```bash
+hermes cron create "0 9 * * 1" \
+  "Generate a weekly AI news digest covering the past 7 days:
+
+1. Search the web for major AI announcements, model releases, and research breakthroughs
+2. Search for trending ML repositories on GitHub
+3. Check arXiv for highly-cited papers on language models and agents
+
+Structure:
+## Headlines (3-5 major stories)
+## Notable Papers (2-3 papers with one-sentence summaries)
+## Open Source (interesting new repos or major releases)
+## Industry Moves (funding, acquisitions, launches)
+
+Keep each item to 1-2 sentences. Include links. Total under 600 words." \
+  --name "Weekly AI digest" \
+  --deliver telegram
+```
+
+### Paper Digest with Notes
+
+Daily arXiv scan that saves summaries to your note-taking system.
+
+**Trigger:** Schedule (daily)
+
+```bash
+hermes cron create "0 8 * * *" \
+  "Search arXiv for the 3 most interesting papers on 'language model reasoning' OR 'tool-use agents' from the past day. For each paper, create an Obsidian note with the title, authors, abstract summary, key contribution, and potential relevance to Hermes Agent development." \
+  --skills "arxiv,obsidian" \
+  --name "Paper digest" \
+  --deliver local
+```
+
+---
+
+## GitHub Event Automations
+
+### Issue Auto-Labeling
+
+Automatically label and respond to new issues.
+
+**Trigger:** GitHub webhook
+
+```bash
+hermes webhook subscribe github-issues \
+  --events "issues" \
+  --prompt "New GitHub issue received:
+Repository: {repository.full_name}
+Issue #{issue.number}: {issue.title}
+Author: {issue.user.login}
+Action: {action}
+Body: {issue.body}
+Labels: {issue.labels}
+
+If this is a new issue (action=opened):
+1. Read the issue title and body carefully
+2. Suggest appropriate labels (bug, feature, docs, security, question)
+3. If it's a bug report, check if you can identify the affected component from the description
+4. Post a helpful initial response acknowledging the issue
+
+If this is a label or assignment change, respond with [SILENT]." \
+  --deliver github_comment
+```
+
+### CI Failure Analysis
+
+Analyze CI failures and post diagnostics on the PR.
+
+**Trigger:** GitHub webhook
+
+```yaml
+# config.yaml route
+platforms:
+  webhook:
+    enabled: true
+    extra:
+      routes:
+        ci-failure:
+          events: ["check_run"]
+          secret: "ci-secret"
+          prompt: |
+            CI check failed:
+            Repository: {repository.full_name}
+            Check: {check_run.name}
+            Status: {check_run.conclusion}
+            PR: #{check_run.pull_requests.0.number}
+            Details URL: {check_run.details_url}
+
+            If conclusion is "failure":
+            1. Fetch the log from the details URL if accessible
+            2. Identify the likely cause of failure
+            3. Suggest a fix
+            If conclusion is "success", respond with [SILENT].
+          deliver: "github_comment"
+          deliver_extra:
+            repo: "{repository.full_name}"
+            pr_number: "{check_run.pull_requests.0.number}"
+```
+
+### Auto-Port Changes Across Repos
+
+When a PR merges in one repo, automatically port the equivalent change to another.
+
+**Trigger:** GitHub webhook
+
+```bash
+hermes webhook subscribe auto-port \
+  --events "pull_request" \
+  --prompt "PR merged in the source repository:
+Repository: {repository.full_name}
+PR #{pull_request.number}: {pull_request.title}
+Author: {pull_request.user.login}
+Action: {action}
+Merge commit: {pull_request.merge_commit_sha}
+
+If action is 'closed' and pull_request.merged is true:
+1. Fetch the diff: curl -sL {pull_request.diff_url}
+2. Analyze what changed
+3. Determine if this change needs to be ported to the Go SDK equivalent
+4. If yes, create a branch, apply the equivalent changes, and open a PR on the target repo
+5. Reference the original PR in the new PR description
+
+If action is not 'closed' or not merged, respond with [SILENT]." \
+  --skills "github-pr-workflow" \
+  --deliver log
+```
+
+---
+
+## Business Operations
+
+### Stripe Payment Monitoring
+
+Track payment events and get summaries of failures.
+
+**Trigger:** API call (webhook)
+
+```bash
+hermes webhook subscribe stripe-payments \
+  --events "payment_intent.succeeded,payment_intent.payment_failed,charge.dispute.created" \
+  --prompt "Stripe event received:
+Event type: {type}
+Amount: {data.object.amount} cents ({data.object.currency})
+Customer: {data.object.customer}
+Status: {data.object.status}
+
+For payment_intent.payment_failed:
+- Identify the failure reason from {data.object.last_payment_error}
+- Suggest whether this is a transient issue (retry) or permanent (contact customer)
+
+For charge.dispute.created:
+- Flag as urgent
+- Summarize the dispute details
+
+For payment_intent.succeeded:
+- Brief confirmation only
+
+Keep responses concise for the ops channel." \
+  --deliver slack
+```
+
+### Daily Revenue Summary
+
+Compile key business metrics every morning.
+
+**Trigger:** Schedule (daily)
+
+```bash
+hermes cron create "0 8 * * *" \
+  "Generate a morning business metrics summary.
+
+Search the web for:
+1. Current Bitcoin and Ethereum prices
+2. S&P 500 status (pre-market or previous close)
+3. Any major tech/AI industry news from the last 12 hours
+
+Format as a brief morning briefing, 3-4 bullet points max.
+Deliver as a clean, scannable message." \
+  --name "Morning briefing" \
+  --deliver telegram
+```
+
+---
+
+## Multi-Skill Workflows
+
+### Security Audit Pipeline
+
+Combine multiple skills for a comprehensive weekly security review.
+
+**Trigger:** Schedule (weekly)
+
+```bash
+hermes cron create "0 3 * * 0" \
+  "Run a comprehensive security audit of the hermes-agent codebase.
+
+1. Check for dependency vulnerabilities (pip audit, npm audit)
+2. Search the codebase for common security anti-patterns:
+   - Hardcoded secrets or API keys
+   - SQL injection vectors (string formatting in queries)
+   - Path traversal risks (user input in file paths without validation)
+   - Unsafe deserialization (pickle.loads, yaml.load without SafeLoader)
+3. Review recent commits (last 7 days) for security-relevant changes
+4. Check if any new environment variables were added without being documented
+
+Write a security report with findings categorized by severity (Critical, High, Medium, Low).
+If nothing found, report a clean bill of health." \
+  --skills "codebase-security-audit" \
+  --name "Weekly security audit" \
+  --deliver telegram
+```
+
+### Content Pipeline
+
+Research, draft, and prepare content on a schedule.
+
+**Trigger:** Schedule (weekly)
+
+```bash
+hermes cron create "0 10 * * 3" \
+  "Research and draft a technical blog post outline about a trending topic in AI agents.
+
+1. Search the web for the most discussed AI agent topics this week
+2. Pick the most interesting one that's relevant to open-source AI agents
+3. Create an outline with:
+   - Hook/intro angle
+   - 3-4 key sections
+   - Technical depth appropriate for developers
+   - Conclusion with actionable takeaway
+4. Save the outline to ~/drafts/blog-$(date +%Y%m%d).md
+
+Keep the outline to ~300 words. This is a starting point, not a finished post." \
+  --name "Blog outline" \
+  --deliver local
+```
+
+---
+
+## Quick Reference
+
+### Cron Schedule Syntax
+
+| Expression | Meaning |
+|-----------|---------|
+| `every 30m` | Every 30 minutes |
+| `every 2h` | Every 2 hours |
+| `0 2 * * *` | Daily at 2:00 AM |
+| `0 9 * * 1` | Every Monday at 9:00 AM |
+| `0 9 * * 1-5` | Weekdays at 9:00 AM |
+| `0 3 * * 0` | Every Sunday at 3:00 AM |
+| `0 */6 * * *` | Every 6 hours |
+
+### Delivery Targets
+
+| Target | Flag | Notes |
+|--------|------|-------|
+| Same chat | `--deliver origin` | Default — delivers to where the job was created |
+| Local file | `--deliver local` | Saves output, no notification |
+| Telegram | `--deliver telegram` | Home channel, or `telegram:CHAT_ID` for specific |
+| Discord | `--deliver discord` | Home channel, or `discord:CHANNEL_ID` |
+| Slack | `--deliver slack` | Home channel |
+| SMS | `--deliver sms:+15551234567` | Direct to phone number |
+| Specific thread | `--deliver telegram:-100123:456` | Telegram forum topic |
+
+### Webhook Template Variables
+
+| Variable | Description |
+|----------|-------------|
+| `{pull_request.title}` | PR title |
+| `{issue.number}` | Issue number |
+| `{repository.full_name}` | `owner/repo` |
+| `{action}` | Event action (opened, closed, etc.) |
+| `{__raw__}` | Full JSON payload (truncated at 4000 chars) |
+| `{sender.login}` | GitHub user who triggered the event |
+
+### The [SILENT] Pattern
+
+When a cron job's response contains `[SILENT]`, delivery is suppressed. Use this to avoid notification spam on quiet runs:
+
+```
+If nothing noteworthy happened, respond with [SILENT].
+```
+
+This means you only get notified when the agent has something to report.

website/sidebars.ts

@@ -153,6 +153,7 @@ const sidebars: SidebarsConfig = {
         'guides/use-voice-mode-with-hermes',
         'guides/build-a-hermes-plugin',
         'guides/automate-with-cron',
+        'guides/automation-templates',
         'guides/cron-troubleshooting',
         'guides/work-with-skills',
         'guides/delegation-patterns',