📊 Performance Marketing Weekly Intel

Full engineering documentation — system design, pipeline flow, configuration, source code, prompts, and operations.
Authored: June 15, 2026  ·  Version 2.2  ·  Engineer-level detail

Table of Contents

• 1. System Overview
• 1.1 Architecture Diagram
• 1.2 Component Inventory
• 1.3 Key Numbers
• 2. Pipeline Flow (End-to-End)
• 2.1 Step 1 — Feed Scanning (perf-marketing-scan.py)
• 2.2 Step 2 — Article Fetching (blogwatcher-cli)
• 2.3 Step 3 — LLM Curation
• 2.4 Step 4 — Webhook Delivery to Slack
• 3. Scheduling
• 3.1 Cron Job Configuration
• 3.2 Timezone & DST
• 4. Date Calculation Logic
• 4.1 Algorithm
• 4.2 Worked Examples
• 5. Source Code
• 5.1 Pre-Run Script (perf-marketing-scan.py)
• 5.2 Shell Wrapper (perf-marketing-scan.sh)
• 6. LLM Prompt (Full Text)
• 7. Curation Rules
• 7.1 Four Pillars
• 7.2 Include / Skip Matrix
• 8. Output Format Specification
• 8.1 Formatting Rules
• 8.2 Annotated Sample
• 9. Webhook Integration (Make.com)
• 9.1 Payload Format
• 9.2 cURL Example
• 10. RSS Feed Inventory (34 Feeds)
• 11. Operations
• 11.1 Manual Run
• 11.2 Check Status
• 11.3 Pause / Resume / Delete
• 11.4 Test Webhook
• 12. Troubleshooting
• 12.1 Wrong Dates in Title
• 12.2 No Articles Returned
• 12.3 Brief Not Arriving in Slack
• 12.4 Feeds Failing to Scan
• 12.5 LLM Producing Wrong Format
• 13. File Manifest
• 14. Dependencies
• 15. Changelog & Known Issues

1. System Overview

The Performance Marketing Weekly Intel system is a fully automated intelligence pipeline that scans 34 RSS feeds every Monday at 9 AM SGT, extracts articles from the previous week, runs them through an LLM for curation, formats the results as a Slack-ready brief, and delivers it to a marketing agency's Slack workspace via a Make.com webhook.

The system is implemented as a Hermes Agent cron job backed by a Python pre-run script and the blogwatcher-cli RSS reader. The LLM (deepseek-v4-flash) handles curation and formatting, while all deterministic computation (dates, feed scanning) happens in the script layer.

1.1 Architecture Diagram

1.2 Component Inventory

1.3 Key Numbers

2. Pipeline Flow (End-to-End)

2.1 Step 1 — Script Execution (perf-marketing-scan.py)

When the cron job fires, the scheduler first executes perf-marketing-scan.py as a pre-run script. The script's stdout is captured and injected into the LLM's context before the prompt runs. v2.1: The script now handles both scanning AND article fetching — the LLM never touches blogwatcher-cli.

What the script does:

1. Calls date.today() to get the current date
2. Computes the previous Monday–Sunday date range (see §4)
3. Runs blogwatcher-cli scan against all 34 feeds with BLOGWATCHER_YES=true
4. Runs blogwatcher-cli articles --all with the computed date filters to fetch last week's articles
5. Outputs labeled blocks that the LLM consumes verbatim

=== METADATA ===
DATE_RANGE: June 8–14, 2026
TITLE_LINE: :bar_chart: *Weekly Intel — June 8–14, 2026*
ARTICLE_SINCE: --since 2026-06-08
ARTICLE_BEFORE: --before 2026-06-15

=== ARTICLES ===
[1] [new] Article Title
     Blog: Blog Name
     URL: https://example.com/article
     Published: 2026-06-10
     Categories: Marketing, AI
[2] [new] ...

2.2 Step 2 — Articles Delivered (Script-Does-Everything)

v2.1 architecture change: The pre-run script now handles everything deterministically — scanning feeds AND fetching articles. The LLM never touches blogwatcher-cli.

The script (perf-marketing-scan.py) runs two operations before the LLM session starts:

1. blogwatcher-cli scan — refreshes all 34 RSS feeds
2. blogwatcher-cli articles --all ARTICLE_SINCE ARTICLE_BEFORE — fetches ONLY last week's articles

Both outputs (scan results + article list + metadata) are captured and injected into the LLM's context as labeled blocks (=== METADATA === and === ARTICLES ===). The LLM simply reads them — it never runs blogwatcher-cli commands. This eliminates the #2 failure mode where the LLM would forget to run the fetch, run it twice, or corrupt the date flags.

2.3 Step 3 — LLM Curation

The LLM (deepseek/deepseek-v4-flash via OpenRouter, downgraded from v4-pro June 15) receives:

• The blogwatcher skill (injected first — contains tool docs, CLI reference)
• The script stdout (injected second — contains date range, metadata, AND all pre-fetched articles)
• The cron job prompt (injected third — the task instruction)

The LLM never runs blogwatcher-cli. Articles arrive pre-fetched in the === ARTICLES === context block.

The LLM then executes these sub-steps (all articles are already in context — no terminal commands needed for fetching):

2.4 Step 4 — Webhook Delivery to Slack

The LLM runs a curl command to POST the formatted brief to Make.com:

curl -s -X POST \
  "https://hook.eu2.make.com/8coauj26hwk726pimcq5r8gj8tian5c5" \
  -H "Content-Type: application/json" \
  -d '{"data":"...formatted brief with escaped newlines..."}'

Make.com receives the payload and runs an automation scenario that formats and delivers the message to the designated Slack channel. The exact Slack channel is configured inside Make.com, not in the cron job — changing the destination requires editing the Make.com scenario, not the cron job.

3. Scheduling

3.1 Cron Job Configuration

3.2 Timezone & DST Considerations

The cron expression 0 1 * * 1 fires at 01:00 UTC. Singapore Standard Time (SGT) is UTC+8 with no daylight saving time, so the SGT delivery time is a stable 09:00 every Monday year-round. No DST shifts to handle.

Scheduler mechanics: The Hermes cron scheduler ticks every 60 seconds. On each tick, it loads all jobs from /opt/data/cron/jobs.json, filters to those where next_run_at ≤ now, and executes them in fresh, isolated agent sessions. After execution, next_run_at is advanced by one week.

4. Date Calculation Logic

This is the most critical piece of the pipeline. The pre-run script computes the correct reporting period programmatically — the LLM never performs date arithmetic.

4.1 Algorithm

# Python implementation (from perf-marketing-scan.py)
from datetime import date, timedelta

def get_last_monday():
    today = date.today()
    # Monday = 0, Sunday = 6
    current_monday = today - timedelta(days=today.weekday())
    # The cron runs ON Monday, so "last week" = previous Monday
    return current_monday - timedelta(days=7)

def get_date_range():
    mon = get_last_monday()       # e.g. June 8
    sun = mon + timedelta(days=6) # e.g. June 14

    if mon.month == sun.month:
        return f"{mon.strftime('%B')} {mon.day}–{sun.day}, {sun.year}"
    else:
        # Handle cross-month ranges: "June 29 – July 5, 2026"
        return f"{mon.strftime('%B %d')} – {sun.strftime('%B %d, %Y')}"

4.2 Worked Examples

5. Source Code

5.1 Pre-Run Script

📄 /opt/data/scripts/perf-marketing-scan.py

#!/usr/bin/env python3
"""
Performance Marketing Weekly Intel — pre-scan script.
Runs blogwatcher-cli scan and computes the correct date range
for the weekly brief title (last Monday through last Sunday).

Output: scan results + DATE_RANGE line for the LLM to use.
"""
import subprocess
import sys
from datetime import date, timedelta

def get_last_monday() -> date:
    """Get the PREVIOUS week's Monday (not today if today is Monday).

    The cron runs every Monday, so 'last week' means the week that just ended.
    Example: running on Monday June 15 → returns Monday June 8.
    """
    today = date.today()
    # Monday = 0, Sunday = 6
    days_since_monday = today.weekday()
    # Go back to the start of the current week, then back 7 more days
    current_monday = today - timedelta(days=days_since_monday)
    return current_monday - timedelta(days=7)

def get_date_range() -> str:
    """Return 'Month D–D, YYYY' for last Monday through Sunday."""
    mon = get_last_monday()
    sun = mon + timedelta(days=6)

    if mon.month == sun.month:
        return f"{mon.strftime('%B')} {mon.day}–{sun.day}, {sun.year}"
    else:
        return f"{mon.strftime('%B %d')} – {sun.strftime('%B %d, %Y')}"


def main():
    date_range = get_date_range()

    # Run blogwatcher-cli scan
    result = subprocess.run(
        ["blogwatcher-cli", "scan"],
        env={"PATH": f"{subprocess.os.path.expanduser('~/.local/bin')}:"
                     f"{subprocess.os.environ.get('PATH', '')}",
             "BLOGWATCHER_YES": "true",
             "HOME": subprocess.os.environ.get("HOME", "/root")},
        capture_output=True,
        text=True,
        timeout=120
    )

    if result.returncode != 0:
        print(f"SCAN_ERROR: {result.stderr}", file=sys.stderr)
        print(result.stdout)

    # Output date range info for the LLM to use
    mon = get_last_monday()
    sun = mon + timedelta(days=6)

    print(f"\nDATE_RANGE: {date_range}")
    print(f"TITLE_LINE: :bar_chart: *Weekly Intel — {date_range}*")
    # CLI flags for blogwatcher-cli articles filtering
    print(f"ARTICLE_SINCE: --since {mon.isoformat()}")
    # BEFORE uses Monday of following week (exclusive boundary)
    print(f"ARTICLE_BEFORE: --before {(sun + timedelta(days=1)).isoformat()}")


if __name__ == "__main__":
    main()

5.2 Shell Wrapper

📄 /opt/data/home/.hermes/scripts/perf-marketing-scan.sh

#!/usr/bin/env bash
# Cron script wrapper — activates venv before running the Python scan
cd /opt/data/scripts
/opt/hermes/.venv/bin/python perf-marketing-scan.py

6. LLM Prompt (Full Text)

This is the exact prompt stored in the cron job at /opt/data/cron/jobs.json. It is injected after the blogwatcher skill and the script stdout (which already contains the pre-fetched articles). Updated June 15, 2026: v2.1 script-does-everything pattern — the LLM reads articles from context rather than running blogwatcher-cli itself.

7. Curation Rules

7.1 Four Pillars

7.2 Include / Skip Matrix

8. Output Format Specification

8.1 Formatting Rules

8.2 Annotated Sample Output

:bar_chart: *Weekly Intel — June 8–14, 2026*     ← TITLE_LINE from script (verbatim)


:robot_face: *AI Trends*                           ← Pillar header (bold)
• OpenAI + Visa partnership lets AI agents make purchases — could reshape ad checkout flows. <https://example.com/1|Read more>   ← Plain text + linked "Read more"


:mega: *Marketing Updates*                         ← Double blank line before each pillar
• Google enlists Walmart Connect for YouTube ad insights — retail media + video convergence. <https://example.com/2|Read more>


:iphone: *Platform Updates*
• Meta unwinds Singapore-based Manus deal — SEA creator monetization impact. <https://example.com/3|Read more>


:flag-sg: *Singapore Business*
• Stripe moves global product head to Singapore — payments infra signal. <https://example.com/4|Read more>


:pushpin: *Worth Monitoring*                       ← One-liners, each with its own URL
• Item — context. 
• Item — context. 

9. Webhook Integration (Make.com)

9.1 Payload Format

9.2 cURL Example

curl -s -X POST \
  "https://hook.eu2.make.com/8coauj26hwk726pimcq5r8gj8tian5c5" \
  -H "Content-Type: application/json" \
  -d '{"data":":bar_chart: *Weekly Intel — June 8–14, 2026*\n\n:robot_face: *AI Trends*\n• OpenAI + Visa lets AI agents buy — checkout flow impact. \n\n:mega: *Marketing Updates*\n• Google enlists Walmart for YouTube insights — retail media. "}'

10. RSS Feed Inventory (34 Feeds)

11. Operations

11.1 Manual Run

Trigger the full pipeline immediately (useful for testing or if Monday was missed):

hermes cron run fe5decb8d413

This runs in the current CLI session — you'll see the LLM's output stream in real time.

11.2 Check Status

hermes cron list

Shows all jobs with their state, next run time, and last status.

11.3 Pause / Resume / Delete

hermes cron pause fe5decb8d413     # Pause (won't fire next Monday)
hermes cron resume fe5decb8d413    # Resume
hermes cron remove fe5decb8d413    # Delete permanently

11.4 Test Webhook

Test the Make.com webhook independently of the full pipeline:

curl -s -X POST \
  "https://hook.eu2.make.com/8coauj26hwk726pimcq5r8gj8tian5c5" \
  -H "Content-Type: application/json" \
  -d '{"data":"🧪 *Test message from Hermes — please ignore*"}'

11.5 Inspect the Cron Job Definition

cat /opt/data/cron/jobs.json | python3 -m json.tool

12. Troubleshooting

12.1 Wrong Dates in Title

12.2 No Articles Returned

cd /opt/data/scripts && /opt/hermes/.venv/bin/python perf-marketing-scan.py

sqlite3 ~/.blogwatcher-cli/blogwatcher-cli.db "SELECT COUNT(*) FROM articles;"

12.3 Brief Not Arriving in Slack

python3 -c "
import json
with open('/opt/data/cron/jobs.json') as f:
    jobs = json.load(f)
j = jobs['jobs'][0]
print(f'Status: {j[\"last_status\"]}')
print(f'Delivery error: {j.get(\"last_delivery_error\", \"none\")}')"

12.4 Feeds Failing to Scan

blogwatcher-cli scan "Adweek"

blogwatcher-cli blogs | grep -A2 "Feed Name"

blogwatcher-cli remove "Old Name" --yes
blogwatcher-cli add "New Name" https://new-url.com --feed-url https://new-url.com/feed.xml

12.5 LLM Producing Wrong Format

hermes cron edit fe5decb8d413  # interactive editor

13. File Manifest

14. Dependencies

15. Changelog & Known Issues

v2.2 — June 15, 2026

• Fixed Worth Monitoring items now have individual <URL|Read more> per item (was dot-separated list without URLs)
• Fixed Format rules clarified: EVERY bullet MUST end with <URL|Read more> — never output "Read more" as plain text
• Fixed Tested live: cron run confirmed proper format with clickable URLs on all items including Worth Monitoring

v2.1 — June 15, 2026 (evening)

• Fixed Webhook payload: changed from nested {"data": {"text": "..."}} to flat {"data": "..."} — nested format was silently failing on Make.com
• Fixed Link format: only "Read more" is linked — titles and context are plain text. Old format linked the entire line
• Changed Architecture: articles now pre-fetched by script (not LLM) — script-does-everything pattern eliminates LLM fetch errors
• Changed Model: downgraded from deepseek-v4-pro to v4-flash to cut costs (user-requested June 15)
• Updated Documentation: prompt, format spec, sample output, webhook, and troubleshooting all synced to current state

v2.0 — June 15, 2026

• Fixed Date calculation: pre-run script pattern eliminates LLM guessing dates
• Added Comprehensive engineering documentation (this file)
• Added GitHub upload workflow (private-file-hermes repo)
• Added GITHUB_TOKEN to ~/.hermes/.env
• Known Slack direct delivery via cron origin fails ("platform 'slack' not configured/enabled") — webhook is the working path
• Known Webhook payload format was incorrect (nested data.text) — fixed in v2.1

v1.0 — June 12, 2026

• Initial deployment: 34 feeds, 4 pillars, Monday 9am SGT schedule
• Used deepseek-v4-flash via OpenRouter

📊 Performance Marketing Weekly Intel — Engineering Docs v2.2
Last updated: June 15, 2026  ·  Job ID: fe5decb8d413  ·  34 feeds  ·  24 runs completed  ·  GitHub: social-wiz/private-file-hermes