┌─────────────────────────────────────────────────────────┐
│  TRIGGER (event / schedule)                             │
└─────────────────┬───────────────────────────────────────┘
                  ▼
┌─────────────────────────────────────────────────────────┐
│  INPUT VALIDATION — schema check, guardrail scan       │
└─────────────────┬───────────────────────────────────────┘
                  ▼
┌─────────────────────────────────────────────────────────┐
│  HUMAN GATE 1: Brief/Strategy Approval                 │
│  (Does this brief/ICP/campaign brief make sense?)      │
└─────────────────┬───────────────────────────────────────┘
                  ▼
┌─────────────────────────────────────────────────────────┐
│  ACTION SEQUENCE (agent executes steps)                │
│  Loop if needed (retry on failure, max N attempts)     │
└─────────────────┬───────────────────────────────────────┘
                  ▼
┌─────────────────────────────────────────────────────────┐
│  OUTPUT VALIDATION — quality check, compliance scan    │
└─────────────────┬───────────────────────────────────────┘
                  ▼
┌─────────────────────────────────────────────────────────┐
│  HUMAN GATE 2: Pre-Publish / Pre-Send Approval        │
│  (Is this output brand-safe, accurate, approved?)     │
└─────────────────┬───────────────────────────────────────┘
                  ▼
┌─────────────────────────────────────────────────────────┐
│  DISTRIBUTION / DELIVERY                                │
└─────────────────────────────────────────────────────────┘

# ============================================================
# CANONICAL MARKETING AGENT WORKFLOW TEMPLATE
# ============================================================
# Copy and customize for each channel agent.
# Compatible with n8n, Temporal, Make, or custom agent runtimes.

workflow_schema_version: "1.0"
agent_name: "<channel>-agent"
workflow_name: "<descriptive-name>"

# ----------------------------------------------------------
# TRIGGER
# ----------------------------------------------------------
trigger:
  type: event | schedule | manual
  event:
    source: "<webhook|api|schedule|button>"
    payload_schema:
      type: object
      required: [<field1>, <field2>]
      properties:
        <field1>: { type: string, description: "..." }
        <field2>: { type: number, description: "..." }
  schedule:
    cron: "<0 9 * * 1>"  # Every Monday at 9am UTC
    timezone: "UTC"
  manual:
    requires_approval: true

# ----------------------------------------------------------
# INPUT SCHEMA
# ----------------------------------------------------------
input_schema:
  type: object
  required:
    - brief
    - channel_config
  properties:
    brief:
      type: object
      properties:
        goal:         { type: string }
        audience:     { type: string }
        key_message:  { type: string }
        cta:          { type: string }
        tone:         { type: string, enum: [formal, conversational, bold, technical] }
        constraints:  { type: array, items: { type: string } }
    channel_config:
      type: object
      properties:
        platform:     { type: string }
        posting_time: { type: string }
        hashtag_set:  { type: array, items: { type: string } }
        brand_voice:  { type: string }
    metadata:
      campaign_id:  { type: string }
      owner_email:   { type: string }
      priority:      { type: string, enum: [low, normal, high, urgent] }

# ----------------------------------------------------------
# ACTION SEQUENCE
# ----------------------------------------------------------
action_sequence:
  - id: step_01
    name: "Validate Input and Guardrails"
    tool: "input_validator"
    retry:
      max_attempts: 2
      backoff_seconds: 5
    on_failure: escalate_human
    output: validated_input

  - id: step_02
    name: "Human Gate 1 — Brief Approval"
    tool: "approval_request"
    approver: "owner_email"
    timeout_hours: 24
    on_timeout: skip_and_log | escalate
    output: approved_brief

  - id: step_03
    name: "Generate Output"
    tool: "llm_generation"
    model: "claude-sonnet-4-20250514"
    prompt_template: "<prompt-template-id>"
    temperature: 0.7
    retry:
      max_attempts: 3
      backoff_seconds: 10
    on_failure: escalate_human
    output: raw_output

  - id: step_04
    name: "Quality and Compliance Check"
    tool: "quality_guardrail"
    checks:
      - brand_voice_match: { min_score: 0.80 }
      - factual_accuracy: { enabled: true }
      - prohibited_content: ["<list of brand prohibitions>"]
      - pii_scan: { enabled: true }
      - hallucination_detection: { enabled: true }
    on_failure: escalate_human
    output: validated_output

  - id: step_05
    name: "Human Gate 2 — Pre-Publish Approval"
    tool: "approval_request"
    approver: "owner_email"
    timeout_hours: 8
    on_timeout: escalate
    output: publishable_output

  - id: step_06
    name: "Distribute"
    tool: "<platform_api>"
    output: delivery_receipt

# ----------------------------------------------------------
# OUTPUT FORMAT
# ----------------------------------------------------------
output_format:
  primary:
    type: document
    schema: "<output-schema-id>"
    destination: "gsheet|slack|email|crm|webhook"
  audit_trail:
    type: log
    destination: "logs/<workflow-name>/<run-id>.json"
  notifications:
    - channel: slack
      webhook: "<webhook-url>"
      on: [success, failure, gate_pending]

# ----------------------------------------------------------
# ERROR HANDLING
# ----------------------------------------------------------
error_handling:
  default_retry_policy:
    max_attempts: 3
    backoff: exponential
    base_seconds: 5
  escalation_rules:
    - condition: "step fails after max retries"
      action: escalate_human
      notify: ["owner_email", "slack:#ops-alerts"]
    - condition: "guardrail violation detected"
      action: block_and_notify
      notify: ["owner_email", "slack:#compliance-alerts"]
    - condition: "human gate times out"
      action: escalate_to_backup_approver
    - condition: "output quality score < 0.6"
      action: escalate_human
  fallback:
    - condition: "LLM generation fails"
      fallback_action: "generate_draft_v2_with_fallback_prompt"

# ----------------------------------------------------------
# GUARDRAILS
# ----------------------------------------------------------
guardrails:
  brand:
    voice_check: true
    prohibited_topics: ["<list>"]
    required_elements: ["<e.g., attribution, disclaimer>"]
  compliance:
    - regulation: CAN-SPAM
      checks: ["no_deceptive_headers", "physical_address", "unsubscribe_link"]
    - regulation: GDPR
      checks: ["no_pii_in_outputs", "consent_confirmation"]
    - regulation: FTC
      checks: ["disclosed_sponsored_content", "no_false_testimonials"]
  safety:
    max_frequency_per_day: 10  # posts per channel per day
    blackout_hours: ["22:00-08:00 UTC"]  # no automated posts during off-hours
    pii_detection: true
    hallucination_detection: true

# ----------------------------------------------------------
# MEMORY (persistence across runs)
# ----------------------------------------------------------
memory:
  type: vector_store | structured_kv
  embedding_model: "claude-embeddings"
  persist_runs: true
  recall_window_days: 90
  key_memory:
    - brand_voice_examples
    - top_performing_hooks
    - approved_cta_variations
    - customer_objections_log

workflow_schema_version: "1.0"
agent_name: "content-agent"
workflow_name: "content-multi-format-pipeline"

trigger:
  type: event | schedule
  manual:
    requires_approval: false
  schedule:
    cron: "0 10 * * MON,WED,FRI"
    timezone: "UTC"
  event:
    source: "cms_webhook | slack_command | crm_workflow_trigger"
    payload:
      brief_id: string
      topic: string
      target_audience: string
      formats: array[blog, linkedin, email, twitter]
      urgency: enum[low, normal, high]

input_schema:
  type: object
  required: [brief_id, topic, target_audience, formats]
  properties:
    brief_id:
      type: string
      description: "Unique identifier linking to brief in CMS/KB"
    topic:
      type: string
      description: "Core topic or angle"
    target_audience:
      type: string
      description: "ICP description — role, company stage, pain point"
    key_message:
      type: string
      description: "The one thing the content should communicate"
    cta:
      type: string
      description: "Call to action — download, demo, subscribe, etc."
    tone:
      type: string
      enum: [educational, provocative, conversational, technical, authoritative]
      default: "conversational"
    formats:
      type: array
      items: { enum: [blog, linkedin, email, twitter] }
      minItems: 1
    sources_required:
      type: boolean
      default: true
      description: "Whether to include data citations in output"
    publish_date:
      type: string
      format: date
      description: "Target publish date for scheduling"

action_sequence:
  - id: content_01
    name: "Parse and Validate Brief"
    tool: "brief_parser"
    checks:
      - all_required_fields_present: true
      - topic_not_on_prohibited_list: true
      - audience_is_within_icp: true
    on_failure: return_for_revision
    output: validated_brief

  - id: content_02
    name: "Research Phase"
    tool: "web_research"
    tasks:
      - gather_statistical_evidence: { min_sources: 3 }
      - find_relevant_case_studies: { min_cases: 1 }
      - identify_related_topics_for_internal_links: { min_links: 2 }
    confidence_threshold: 0.7
    on_failure: proceed_with_citations_flagged
    output: research_package

  - id: content_03
    name: "Human Gate 1 — Brief Review"
    tool: "approval_request"
    approver_ref: brief.owner_email
    template: "content_brief_review"
    timeout_hours: 4
    on_timeout: escalate_to_ops_channel
    output: approved_brief

  - id: content_04
    name: "Generate Blog Post"
    tool: "llm_generation"
    model: "claude-sonnet-4-20250514"
    prompt_ref: "prompts/content/blog-post-v3.md"
    variables:
      topic: input.topic
      audience: input.target_audience
      key_message: input.key_message
      cta: input.cta
      tone: input.tone
      research_package: content_02.output
    output_format:
      type: markdown
      sections: [meta_title, meta_description, headline, subheadline, body, conclusion, cta]
      word_count_target: 1800-2400
    on_failure: escalate_human

  - id: content_05
    name: "Generate LinkedIn Post"
    tool: "llm_generation"
    model: "claude-sonnet-4-20250514"
    prompt_ref: "prompts/content/linkedin-post-v2.md"
    variables:
      topic: input.topic
      key_message: input.key_message
      tone: "professional, direct"
      blog_post_summary: content_04.output.summary_for_social
    output_format:
      type: linkedin_post
      sections: [hook_line, body_paragraphs, call_to_action]
      character_limit: 3000
    on_failure: escalate_human

  - id: content_06
    name: "Generate Twitter Thread"
    tool: "llm_generation"
    model: "claude-sonnet-4-20250514"
    prompt_ref: "prompts/content/twitter-thread-v2.md"
    variables:
      topic: input.topic
      key_message: input.key_message
      hook_type: "provocative_claim"
      num_tweets: 6
    output_format:
      type: tweet_thread
      tweets: array
      each_tweet_max_chars: 280
    on_failure: escalate_human

  - id: content_07
    name: "Generate Email Newsletter"
    tool: "llm_generation"
    model: "claude-sonnet-4-20250514"
    prompt_ref: "prompts/content/email-newsletter-v2.md"
    variables:
      topic: input.topic
      key_message: input.key_message
      cta: input.cta
      tone: "warm, direct, value-first"
    output_format:
      type: email
      sections: [subject_line, preview_text, headline, body, cta_button]
      subject_line_variations: 3
    on_failure: escalate_human

  - id: content_08
    name: "Quality and Brand Voice Check"
    tool: "quality_guardrail"
    checks:
      - brand_voice_score: { min: 0.82, tool: "llm_judge" }
      - factual_accuracy: { enabled: true, min_confidence: 0.85 }
      - hallucination_check: { enabled: true, claim_db: "internal_kb" }
      - readability_score: { min: 65, tool: "flesch_kincaid" }
      - unique_angle_check: { min_similarity_to_past: 0.7 }
    on_failure: regenerate_with_feedback
    output: quality_scored_content

  - id: content_09
    name: "Human Gate 2 — Multi-Format Output Review"
    tool: "approval_request"
    approver_ref: brief.owner_email
    template: "content_output_review"
    timeout_hours: 8
    include_outputs:
      - blog_post: content_04.output.markdown
      - linkedin_post: content_05.output.text
      - twitter_thread: content_06.output.thread_json
      - email_draft: content_07.output.email_html
    on_timeout: escalate_to_ops_channel
    on_approval: mark_approved_and_route_to_publish
    on_rejection: return_for_revision
    output: publishable_content_package

  - id: content_10
    name: "Distribute to Scheduling Tool"
    tool: "buffer_api | hypefury_api | native_scheduler"
    routing:
      blog: "cms_api"
      linkedin: "buffer_linkedin"
      twitter: "hypefury_twitter"
      email: "mailchimp_api | kit_api"
    scheduled_dates:
      blog: input.publish_date
      linkedin: input.publish_date + 1
      twitter: input.publish_date + 0  # same day, morning
      email: input.publish_date + 2
    output: distribution_receipt

  - id: content_11
    name: "Log Performance Expectations"
    tool: "crm_update"
    fields:
      content_id: content_04.output.canonical_url
      formats_published: input.formats
      publish_dates: content_10.output.scheduled_dates
      next_review_date: content_10.output.scheduled_dates.max + 30_days
      quality_score: content_08.output.overall_score

# ----------------------------------------------------------
# PROMPT TEMPLATES (referenced by ID)
# ----------------------------------------------------------
prompt_templates:
  blog-post-v3: |
    You are a B2B SaaS content writer for a [brand voice] brand.
    Write a long-form blog post on: {{topic}}
    Target audience: {{target_audience}}
    Core message: {{key_message}}
    CTA: {{cta}}
    Tone: {{tone}}

    Research package:
    {{research_package}}

    Include:
    - SEO-optimized meta title (≤60 chars) and meta description (≤155 chars)
    - A compelling headline and subheadline
    - H2/H3 structure with at least 4 sections
    - Data-backed claims with in-text citations
    - At least 2 internal link placeholders [LINK: topic_slug]
    - A conclusion that reinforces {{key_message}} and leads to {{cta}}

    Brand voice guidelines:
    - Avoid: buzzwords, passive voice, generic statements
    - Always: lead with the outcome, use specific numbers, speak to buyer pain
    - Example brand voice: "Direct. Technical where it matters. Outcome-obsessed."

    Output as JSON: { meta_title, meta_description, headline, subheadline, body_markdown, conclusion }

  linkedin-post-v2: |
    You are a B2B SaaS LinkedIn content writer.
    Write a LinkedIn post based on this blog summary:
    {{blog_post_summary}}

    Hook: First line must stop the scroll — controversial claim or surprising stat
    Body: 3–4 paragraphs, each one paragraph. No bullet points in body.
    CTA: End with a question to drive comments, or direct to the blog link

    Format: [HOOK_LINE]\n\n[BODY]\n\n[CTA]\n[LINK_PLACEHOLDER]
    Max 2,800 characters (LinkedIn limit).

  twitter-thread-v2: |
    Write a {{num_tweets}}-tweet thread on: {{topic}}
    Core message: {{key_message}}

    Tweet 1: HOOK — provocative claim or stat that creates curiosity
    Tweets 2-5: BODY — each tweet covers one sub-point, must stand alone (readable without context)
    Tweet {{num_tweets}}: CTA — ask a question or direct to link/profile

    Rules:
    - Each tweet max 280 characters
    - No cliffhangers at end of tweet (no "→" continuations)
    - Use line breaks within tweets for readability
    - No emoji in tweets 2-5 (hook tweet can use 1 emoji max)
    - Each tweet should be readable without needing the next tweet

    Output as JSON array: { tweets: [{ number, text }] }

  email-newsletter-v2: |
    You are a B2B SaaS email copywriter.
    Write a newsletter email on: {{topic}}
    Core message: {{key_message}}
    CTA: {{cta}}

    Format:
    1. Subject line (3 variations, each <50 chars)
    2. Preview text (≤100 chars, teases the value)
    3. Headline (punchy, max 10 words)
    4. Body (3 short paragraphs, value-first, no fluff)
    5. CTA button text (max 5 words)

    Tone: warm, direct, like a smart colleague sharing a useful find.
    Do not: use ALL CAPS, excessive exclamation points, clickbait subject lines
    Always: open with the outcome, cite data, personalize where possible

    Output as JSON: { subject_lines: [], preview_text, headline, body_paragraphs: [], cta_text }

workflow_schema_version: "1.0"
agent_name: "outbound-agent"
workflow_name: "abm-outbound-orchestration"

trigger:
  type: event | schedule
  event:
    source: "crm_trigger | intent_data_webhook | intent_signal"
    payload:
      trigger_type: enum[new_company_list, intent_signal, account_update, manual_upload]
      account_list_id: string
      campaign_id: string
  schedule:
    # Run ICP scoring daily for new intent signals
    cron: "0 6 * * *"
    timezone: "UTC"

input_schema:
  type: object
  required: [campaign_id, icp_definition]
  properties:
    campaign_id:
      type: string
      description: "CRM campaign ID linking to sequence config"
    icp_definition:
      type: object
      description: "ICP criteria — see ICP Scoring Formula below"
      properties:
        firmographics:
          employee_range: { type: string, enum: ["1-10","11-50","51-200","201-1000","1000+"] }
          industry: { type: array, items: { string } }
          geography: { type: array, items: { string } }
          tech_stack: { type: array, items: { string } }  # e.g., ["salesforce", "hubspot"]
          funding_stage: { type: string }
        personas:
          - role: { type: string }
            seniority: { type: array, items: { enum: [ic, manager, director, vp, cxo] } }
            pain_points: { type: array, items: { string } }
        intent_signals:
          - signal_type: { type: enum[content_download, pricing_visit, competitor_visit, job_posting, funding_news, linkedin_engagement] }
            weight: { type: number }
        revenue_tier:
          enterprise: { type: object, properties: { min_arr_usd: number, priority: string } }
          mid_market: { type: object, properties: { min_arr_usd: number, priority: string } }
          smb: { type: object, properties: { min_arr_usd: number, priority: string } }
    sequence_config:
      type: object
      properties:
        channels: { type: array, items: { enum: [email, linkedin, phone] } }
        num_touchpoints: { type: number, default: 6 }
        days_to_complete: { type: number, default: 21 }
        personalization_depth: { type: enum[generic, account, contact, hyper_personalized] }
        human_in_loop: { type: boolean, default: true }
        escalation_on_reply: { type: boolean, default: true }

# ----------------------------------------------------------
# ICP SCORING FORMULA
# ----------------------------------------------------------
# Used to rank and prioritize accounts in the outbound queue.
# Score = (Fit Score × 0.35) + (Intent Score × 0.40) + (Revenue Multiplier × 0.25)

icp_scoring:
  fit_score:
    # 0–100 based on firmographic + persona match
    dimensions:
      employee_range_match:  # ICP-defined range match
        exact_match: 100
        adjacent_range: 60
        outside_range: 10
      industry_match:
        primary_industry: 40
        adjacent_industry: 20
        other: 0
      seniority_match:
        cxo: 30
        vp: 25
        Director: 20
        Manager: 10
        IC: 5
      tech_stack_relevance:  # How many relevant tools in their stack
        3+: 30
        2: 20
        1: 10
        0: 0
    total_max: 100

  intent_score:
    # Real-time behavioral signals
    signals:
      content_download:
        weight: 15
        max_score: 30
      pricing_visit:
        weight: 25
        max_score: 50
      competitor_visit:
        weight: 20
        max_score: 40
      job_posting_relevant:
        weight: 15
        max_score: 30
      funding_news:
        weight: 10
        max_score: 20
      linkedin_engagement:
        weight: 5
        max_score: 10
    decay:  # Intent signals decay over time
      half_life_days: 14
      minimum_days_since_signal: 3

  revenue_multiplier:
    # Applied as multiplier (0.5x to 3.0x) on effort investment
    tiers:
      enterprise:
        arr_potential_usd: ">100k"
        multiplier: 3.0
        max_daily_volume: 50  # accounts per day
      mid_market:
        arr_potential_usd: "20k-100k"
        multiplier: 1.5
        max_daily_volume: 100
      smb:
        arr_potential_usd: "<20k"
        multiplier: 0.5
        max_daily_volume: 200

  final_score_formula: |
    account_score = (fit_score × 0.35) + (intent_score × 0.40) + (revenue_multiplier × 25)

    # Accounts must score ≥ 55 to enter active outreach queue
    # Accounts scoring 55–70: standard sequence
    # Accounts scoring 71–85: accelerated sequence (more touchpoints, shorter spacing)
    # Accounts scoring > 85: high-touch with human personalization overlay

action_sequence:
  - id: outbound_01
    name: "Pull Target Account List"
    tool: "crm_query | clay_data"
    query:
      icp_filter: input.icp_definition
      min_score: 55
      max_accounts_per_run: 100
      exclude_previously_contacted: true
      exclude_unsubscribed: true
      exclude_current_customers: true
    output: prioritized_account_list

  - id: outbound_02
    name: "Research Each Account"
    parallel: true  # Run research in parallel for account list
    max_parallel: 10
    tool: "web_research | claygent"
    per_account_tasks:
      - company_news: { sources: ["press_releases", "linkedin", "crunchbase"] }
      - recent_blog_content: { limit: 3 }
      - leadership_changes: { lookback_days: 90 }
      - tech_stack_inference: { from_job_postings: 5 }
      - funding_events: { lookback_days: 180 }
      - relevant Pain Points: { match_to_icp_pains: true }
    output: account_research_package

  - id: outbound_03
    name: "Identify Decision-Maker Contacts"
    tool: "apollo_api | linkedin_sales_navigator | clay_enrich"
    per_account_tasks:
      - find_contacts:
          roles: input.icp_definition.personas[].role
          seniority: input.icp_definition.personas[].seniority
          email_format: "first_last@domain" | "firstinitiallast@domain"
      - validate_emails: { tool: "apollo_validate | zerobounce", min_valid_rate: 0.75 }
      - find_linkedin_profiles: true
    output: contact_list_per_account

  - id: outbound_04
    name: "Generate Personalized Content"
    tool: "llm_generation"
    model: "claude-sonnet-4-20250514"
    prompt_ref: "prompts/outbound/personalized_sequence_v2.md"
    variables:
      account: outbound_02.output.account_research
      contact: outbound_03.output.contact
      key_pain: outbound_02.output.matched_pain_points[0]
      company_recent_news: outbound_02.output.latest_news_item
      personalization_hook: outbound_02.output.best_hook  # e.g., blog reference, funding
    personalization_depth: input.sequence_config.personalization_depth
    output_format:
      email_subject_lines: 3
      email_body: { preview_text, opening_line, body_paragraphs, cta }
      linkedin_message: { opening, body, cta }
    on_failure: use_generic_template
    output: personalized_sequence

  - id: outbound_05
    name: "Human Gate — Sequence Review (High-Touch Accounts)"
    tool: "approval_request"
    condition: "account_score > 85 OR personalization_depth == hyper_personalized"
    approver: "sdr_manager_email"
    include_outputs:
      - email_sequence: personalized_sequence.email_body
      - linkedin_message: personalized_sequence.linkedin_message
    timeout_hours: 4
    on_timeout: send_generic_and_flag
    output: approved_sequence

  - id: outbound_06
    name: "Launch Email Sequence"
    tool: "apollo | instantly | mailshake"
    sequence_config:
      campaign_id: input.campaign_id
      accounts: outbound_01.output.prioritized_account_list
      contacts: outbound_03.output.contact_list
      emails: outbound_04.output.email_bodies
      schedule:
        # Typical sequence timing (example 6-touch)
        touch_1:
          channel: email
          day: 0
          time: "09:00 recipient_tz"
        touch_2:
          channel: linkedin
          day: 2
          time: "10:00 recipient_tz"
        touch_3:
          channel: email
          day: 4
          time: "11:00 recipient_tz"
        touch_4:
          channel: email
          day: 8
          time: "09:00 recipient_tz"
        touch_5:
          channel: linkedin
          day: 12
        touch_6:
          channel: email
          day: 16
          time: "09:00 recipient_tz"
    dkim_spf_setup: required
    unsubscribe_links: required
    tracking: { opens: true, clicks: true, replies: true }
    output: sequence_delivery_receipt

  - id: outbound_07
    name: "Monitor Responses and Score Replies"
    tool: "apollo_webhook | inbox_parser"
    monitoring:
      response_channels: [email_reply, linkedin_reply, bounce, unsubscribe, spam_complaint]
      scoring:
        reply_score_map:
          positive_reply: 100
          meeting_request: 100
          negative_reply: 20
          out_of_office: 10
          bounce_hard: 0
          bounce_soft: 5
          unsubscribe: -100
          spam_complaint: -200
    output: scored_responses

  - id: outbound_08
    name: "Route Responses to Humans"
    tool: "crm_task_creation | slack_notification"
    routing_rules:
      - condition: "reply_score >= 80 AND meeting_request == true"
        action: create_crm_task
        task_type: "book_meeting"
        assignee: "account_executive"
        priority: high
        slack_channel: "#outbound-hot-leads"
      - condition: "reply_score 50-79"
        action: create_crm_task
        task_type: "follow_up"
        assignee: "sdr"
        priority: normal
      - condition: "reply_score < 50"
        action: continue_sequence  # No human action needed, sequence continues
      - condition: "negative_reply OR unsubscribe"
        action: suppress_from_future_campaigns
        crm_update: { status: "suppressed", reason: "negative_signal" }
      - condition: "spam_complaint"
        action: suppress_and_alert
        alert: "slack:#deliverability-alerts"

  - id: outbound_09
    name: "Book Meeting (on positive reply)"
    tool: "calendly_api | chilipiper | human_scheduler"
    condition: "reply_score >= 80"
    calendar_integration: required
    output: meeting_booking_confirmation

  - id: outbound_10
    name: "Weekly Outbound Performance Report"
    tool: "report_generation"
    schedule: "0 8 * * MON"  # Every Monday morning
    metrics:
      emails_sent: sum
      open_rate: percentage
      click_rate: percentage
      reply_rate: percentage
      positive_reply_rate: percentage
      meeting_booked: count
      cost_per_meeting: calculated
      sequence_completion_rate: percentage
      top_hooks_by_response_rate: analyzed
    output:
      format: slack_message | email_html_report
      destination: "slack:#outbound-ops | gsheet"
    output_format:
      slack:
        blocks:
          - metric_card: "Weekly Outbound Summary"
          - table: top_10_accounts_by_score
          - highlight: "Best performing hook this week: [hook_text]"
          - action_items: recommended_adjustments
      email:
        subject: "Outbound Weekly [date]"
        sections: [executive_summary, key_metrics, top_accounts, recommended_actions]

prompts:
  outbound/personalized_sequence_v2: |
    You are a B2B SaaS outbound specialist writing personalized cold outreach.

    ACCOUNT CONTEXT:
    Company: {{account.name}}
    Industry: {{account.industry}}
    Size: {{account.employee_count}} employees
    Recent news: {{account.latest_news}}
    Current challenge (inferred from their content): {{account.matched_pain}}

    CONTACT:
    Name: {{contact.first_name}} {{contact.last_name}}
    Title: {{contact.title}}
    Seniority: {{contact.seniority}}

    PERSONALIZATION HOOK: {{personalization_hook}}
    (Use this as the opening angle — reference their content, a move they made, or their stated challenge)

    OUR VALUE PROP:
    Product category: [Your product category]
    Key outcome: [The specific outcome we deliver]
    Proof point: [Specific metric or customer result]

    EMAIL SEQUENCE — Generate 3 variations:
    Each variation should use a different opening hook from the personalization_hook set.

    For each email:
    - Subject line (3 options: question, stat-based, direct)
    - Preview text (≤100 chars)
    - Opening: Reference personalization_hook. Do NOT start with "I hope this email finds you" or similar.
    - Body: 3–4 short paragraphs. Show you did research. Connect their challenge to our outcome.
    - CTA: Specific next step (not "let's hop on a call" — use softer CTAs like "Would you be open to a 15-min chat?" or "Happy to share how [similar company] handled this")
    - Signature: [Your name], [Your title] at [Company]

    LINKEDIN MESSAGE:
    - Max 300 characters
    - Casual but professional tone
    - Reference the email sent or personalization hook
    - CTA: "Happy to connect" or "Let me know if timing's off"

    GUARDRAILS:
    - Do NOT mention "I found your profile" or "I came across your company"
    - Do NOT use ALL CAPS or more than 1 exclamation point
    - Do NOT claim specific results without data
    - Keep paragraphs short (2–3 sentences max)

workflow_schema_version: "1.0"
agent_name: "analytics-agent"
workflow_name: "marketing-analytics-dashboard-reporting"

trigger:
  type: schedule
  schedule:
    # Daily metric snapshot
    daily: "0 7 * * *"
    # Weekly full report
    weekly: "0 8 * * MON"
    # Monthly executive report
    monthly: "0 8 1 * *"
  event:
    source: "anomaly_detected | campaign_milestone"
    payload:
      alert_type: enum[metric_spike, conversion_drop, budget_threshold, campaign_ended]

input_schema:
  type: object
  required: [report_type, date_range]
  properties:
    report_type:
      type: enum[daily_snapshot, weekly_report, monthly_executive, campaign_retrospective, custom]
    date_range:
      start_date: { type: string, format: date }
      end_date: { type: string, format: date }
    platforms:
      type: array
      items: { enum: [ga4, google_ads, meta_ads, linkedin_ads, hubspot, salesforce, stripe, mailchimp] }
      default: [ga4, hubspot, google_ads, stripe]
    channels:
      type: array
      items: { enum: [paid_search, paid_social, organic, email, outbound, referral, direct] }
    alert_thresholds:
      type: object
      properties:
        traffic_drop_pct: { type: number, default: 20 }
        conversion_rate_drop_pct: { type: number, default: 15 }
        cpc_increase_pct: { type: number, default: 25 }
        roas_drop_pct: { type: number, default: 20 }
        bounce_rate_increase_pct: { type: number, default: 30 }
    output_recipients:
      type: array
      items: { type: string }  # email addresses or Slack channel IDs
    slack_webhook: { type: string }

action_sequence:
  - id: analytics_01
    name: "Pull Data from All Platforms"
    tool: "platform_api"
    parallel: true
    data_sources:
      ga4:
        metrics: [sessions, users, new_users, bounce_rate, avg_session_duration, goal_completions, revenue]
        dimensions: [source_medium, campaign, landing_page]
        date_range: input.date_range
        api_version: "v2"
      google_ads:
        metrics: [clicks, impressions, ctr, cpc, conversions, cost, conversions_value]
        date_range: input.date_range
      meta_ads:
        metrics: [impressions, reach, clicks, ctr, cpc, conversions, amount_spent, result_rate]
        date_range: input.date_range
      hubspot:
        metrics: [new_leads, mqls, sqls, meetings_booked, pipeline_created]
        date_range: input.date_range
      salesforce:
        metrics: [opportunities_created, stage_changes, closed_won, closed_lost, mrr_added]
        date_range: input.date_range
      stripe:
        metrics: [new_subscriptions, churned, mrr_change, trial_to_paid_rate]
        date_range: input.date_range
    on_partial_failure:
      log_missing_source: true
      proceed_with_available: true
      alert_on_missing: true
    output: raw_data_pulls

  - id: analytics_02
    name: "Compute Channel Metrics"
    tool: "metric_computation"
    calculations:
      # CAC by channel (requires cost data + conversions)
      cac_by_channel:
        formula: "channel_cost / conversions"
        channels: [paid_search, paid_social, organic, email, outbound]
      # Blended CAC
      blended_cac:
        formula: "total_marketing_cost / new_customers"
      # ROAS by channel
      roas_by_channel:
        formula: "channel_conversion_value / channel_cost"
        channels: [google_ads, meta_ads, linkedin_ads]
      # LTV:CAC ratio
      ltv_cac_ratio:
        formula: "avg_customer_ltv / blended_cac"
        requires: [avg_ltv_from_stripe, blended_cac]
      # Payback period (months)
      payback_period:
        formula: "blended_cac / avg_monthly_revenue_per_customer"
      # Conversion rates by funnel stage
      visitor_to_lead: "leads / sessions"
      lead_to_mql: "mqls / leads"
      mql_to_sql: "sqls / mqls"
      sql_to_opportunity: "opportunities / sqls"
      opportunity_to_close: "closed_won / opportunities"
      # Pipeline coverage
      pipeline_coverage: "pipeline_value / quota"
      # Email metrics
      email_open_rate: "opens / delivered"
      email_click_rate: "clicks / delivered"
      email_bounce_rate: "bounces / sent"
    output: computed_metrics

  - id: analytics_03
    name: "Anomaly Detection"
    tool: "anomaly_detection"
    method: "statistical_control_chart | isolation_forest | percentile_comparison"
    comparison_window: 28_days  # Compare to prior 28-day period
    thresholds:
      traffic:
        min_change_pct: 20
        direction: both  # flag both drops AND spikes
      conversion_rate:
        min_change_pct: 15
        direction: both
      cost_per_lead:
        min_change_pct: 25
        direction: both
      roas:
        min_change_pct: 20
        direction: down_only
      bounce_rate:
        min_change_pct: 30
        direction: both
    contextual_flags:
      - flag_if: "major holiday in date_range"
        label: "seasonality_adjustment_applied"
      - flag_if: "campaign launched within date_range"
        label: "new_campaign_contribution_isolated"
      - flag_if: "competitor_event_detected"
        label: "external_factor_possible"
    output: anomaly_report

  - id: analytics_04
    name: "Generate Dashboard Summary"
    tool: "llm_synthesis"
    model: "claude-sonnet-4-20250514"
    prompt_ref: "prompts/analytics/dashboard-narrative-v2.md"
    variables:
      computed_metrics: analytics_02.output
      anomaly_report: analytics_03.output
      date_range: input.date_range
      report_type: input.report_type
    narrative_sections:
      - executive_summary: { max_sentences: 5, format: plain_text }
      - wins_highlight: { top_n: 3, metric: highest_improvement }
      - concerns_highlight: { top_n: 3, metric: biggest_drops }
      - channel_performance_ranking: { by: roas | cac | pipeline_generated }
      - recommended_actions: { max: 3, priority: high_to_low }
      - week_over_week_trend: { key_metrics_only: true }
    output: dashboard_narrative

  - id: analytics_05
    name: "Route Outputs to Destinations"
    tool: "multi_destination_dispatch"
    routes:
      slack:
        condition: "report_type == daily_snapshot OR anomaly_detected == true"
        destination: input.slack_webhook
        format: slack_blocks
        channel_override: "#marketing-analytics"
      email:
        condition: "report_type in [weekly_report, monthly_executive]"
        recipients: input.output_recipients
        format: email_html
        subject_template: "{{report_type}} Marketing Report — {{date_range.start}} to {{date_range.end}}"
      gsheet:
        condition: "always"
        destination: "gsheet_id_from_config"
        sheet_name: "{{report_type}}-{{date_range.start_date}}"
        append_to_tracking_sheet: true
    output: delivery_confirmations

  - id: analytics_06
    name: "Alert on Threshold Breaches"
    tool: "slack_notification | email_alert"
    condition: "anomaly_detected == true AND anomaly.severity >= high"
    routing:
      severity_high:
        slack_channel: "#marketing-alerts"
        email_to: ["cmo@company.com", "vp_marketing@company.com"]
        urgency: urgent
      severity_medium:
        slack_channel: "#marketing-ops"
        include_in_weekly: true
    alert_format:
      headline: "{{metric_name}} {{direction}} by {{change_pct}} — Investigate Now"
      context: "{{prior_period_value}} → {{current_period_value}}"
      possible_causes: ["list of 3 most likely causes"]
      recommended_first_step: "{{action}}"
    output: alert_confirmation

# ----------------------------------------------------------
# PROMPT TEMPLATE: Dashboard Narrative
# ----------------------------------------------------------
prompt_templates:
  analytics/dashboard-narrative-v2: |
    You are a B2B SaaS marketing analyst writing a weekly performance narrative.

    REPORT TYPE: {{report_type}}
    DATE RANGE: {{date_range.start}} to {{date_range.end}}

    KEY METRICS:
    {{computed_metrics}}

    ANOMALIES DETECTED:
    {{anomaly_report}}

    Write a clear, concise narrative with these sections:

    1. EXECUTIVE SUMMARY (3–4 sentences)
       - What happened this period in plain English
       - One sentence on the biggest win
       - One sentence on the most important concern

    2. TOP PERFORMING CHANNELS (top 3 by ROAS or pipeline generated)
       For each: channel name, metric, why it performed

    3. CHANNELS NEEDING ATTENTION (top 3 by underperformance)
       For each: channel name, metric, possible cause, recommended action

    4. ANOMALIES AND FLAGS
       For each anomaly: what changed, how much, probable cause, action to take

    5. RECOMMENDED ACTIONS (top 3, specific and actionable)
       Format: "Owner: [Name] — Action: [Specific next step] — By: [Date]"

    TONE: Direct, analytical, no marketing fluff. Think: internal analytics review meeting.
    FORMAT: Markdown with bullet points. No vague statements ("looks good" is not analysis).
    NUMBERS: Always include the actual metric values, not just direction.

workflow_schema_version: "1.0"
agent_name: "community-agent"
workflow_name: "community-monitoring-signal-detection"

trigger:
  type: schedule
  schedule:
    # Real-time monitoring windows (can run more frequently during business hours)
    monitoring_frequency: "every_30_min"
    business_hours_only: true
    timezone: "America/New_York"
  event:
    source: "webhook | keyword_alert | brand_mention_detected"

input_schema:
  type: object
  required: [brand_keywords, competing_brands, product_features]
  properties:
    brand_keywords:
      type: array
      items: { type: string }
      description: "Brand name, product names, founder names, team member handles"
    competing_brands:
      type: array
      items: { type: string }
      description: "Competitor brand names to track"
    product_features:
      type: array
      items: { type: string }
      description: "Feature names that indicate relevant conversations"
    problem_keywords:
      type: array
      items: { type: string }
      description: "Pain points and problem descriptors — detect when people complain about the problem your product solves"
    platforms:
      type: array
      items: { enum: [linkedin, twitter, reddit, hacker_news, product_hunt, slack_communities] }
      default: [linkedin, twitter, reddit, hacker_news]
    signal_types:
      type: array
      items: { enum: [question, complaint, opportunity, mention, praise] }
    escalation_keywords:
      type: array
      items: { type: string }
      description: "Keywords that always trigger human escalation — ['competitor comparison', 'pricing question', 'integration issue', 'enterprise']"

action_sequence:
  - id: community_01
    name: "Pull Brand Mentions Across Platforms"
    tool: "brand_mention_api | social_listening_tool"
    platforms:
      linkedin:
        sources: ["company_mentions", "post_comments", "group_posts"]
        query: "OR(brand_keywords, competing_brands, problem_keywords)"
      twitter:
        sources: ["tweets", "replies", "mentions"]
        query: "brand_keywords OR competing_brands OR problem_keywords"
      reddit:
        sources: ["subreddit_posts", "comments"]
        subreddits: ["relevant_subreddits_list"]
        query: "brand_keywords OR problem_keywords"
      hacker_news:
        sources: ["stories", "comments"]
        query: "brand_keywords OR product_features OR problem_keywords"
    lookback_minutes: 30
    dedup: true
    dedup_key: "post_id"
    on_failure: log_and_retry
    output: raw_mentions

  - id: community_02
    name: "Signal Classification"
    tool: "llm_classifier"
    model: "claude-sonnet-4-20250514"
    prompt_ref: "prompts/community/signal-classifier-v2.md"
    variables:
      mention: raw_mention
      signal_types: input.signal_types
    classification_schema:
      signal_type: enum[question, complaint, opportunity, mention, praise]
      sentiment: enum[positive, neutral, negative]
      urgency: enum[low, medium, high, critical]
      response_recommended: boolean
      response_type: enum[draft_reply, escalate_human, monitor, ignore]
      competitive_signal: boolean  # True if mentioning a competitor
      influence_score: number  # 1-10 based on follower count / upvotes / reach
    confidence_threshold: 0.80
    on_low_confidence: escalate_human
    output: classified_signals

  - id: community_03
    name: "Escalation Filter"
    tool: "rule_based_filter"
    rules:
      - condition: "signal.urgency == critical"
        action: immediate_slack_alert
        slack_channel: "#community-alerts-urgent"
        notify: ["community_manager", "cmo"]
      - condition: "signal.signal_type == complaint AND signal.influence_score >= 7"
        action: escalate_human
        slack_channel: "#community-alerts"
        response_deadline_minutes: 60
      - condition: "any escalation_keyword in signal.text"
        action: escalate_human
        response_deadline_minutes: 120
      - condition: "signal.competitive_signal == true AND signal.signal_type == question"
        action: draft_reply_for_review
        sla_minutes: 240
    output: escalation_queue

  - id: community_04
    name: "Generate Draft Responses"
    tool: "llm_generation"
    model: "claude-sonnet-4-20250514"
    condition: "signal.response_recommended == true AND signal.response_type == draft_reply"
    prompt_ref: "prompts/community/draft-response-v2.md"
    variables:
      signal: classified_signals.signal
      brand_voice: "brand_voice_from_kb"
      platform: signal.platform
      response_length_max: platform.linkedin.max_chars | twitter.max_chars | reddit.max_chars
    on_failure: escalate_human
    output: draft_responses

  - id: community_05
    name: "Human Gate — Response Review"
    tool: "approval_request"
    condition: "signal.response_recommended == true"
    approver: "community_manager_email"
    timeout_minutes: 30
    for_signals:
      - urgent_signals: { response_deadline_minutes: 60 }
      - normal_signals: { response_deadline_minutes: 240 }
    on_timeout: escalate_to_backup
    on_approval: route_to_platform
    on_rejection: escalate_human
    output: approved_responses

  - id: community_06
    name: "Post Approved Responses"
    tool: "linkedin_api | twitter_api | reddit_api"
    condition: "response.approved == true"
    rate_limiting:
      linkedin: { max_per_hour: 10, min_gap_seconds: 300 }
      twitter: { max_per_hour: 20, min_gap_seconds: 180 }
      reddit: { max_per_hour: 5, min_gap_seconds: 600 }
    on_post_success:
      - log_response: { signal_id, response_text, post_url, timestamp }
      - update_signal_status: "responded"
    on_post_failure:
      - retry: { max_attempts: 2, backoff_seconds: 30 }
      - escalate_on_final_failure: true
    output: posted_responses

  - id: community_07
    name: "Weekly Community Summary Report"
    tool: "report_generation"
    schedule: "0 9 * * FRI"
    metrics:
      total_mentions: count
      mentions_by_platform: group_by(platform)
      mentions_by_signal_type: group_by(signal_type)
      avg_sentiment: calculated
      questions_answered: count
      complaints_identified: count
      opportunities_flagged: count
      response_rate: "answered / total_questions"
      avg_response_time_minutes: calculated
      top_influencers: ranked_by(influence_score, limit: 10)
      competitive_mentions: count
      trending_topics: { method: keyword_frequency, top_n: 10 }
    output:
      format: slack_message | email_html
      destinations: ["slack:#community-ops", "community_manager_email"]
      gsheet_append: "community_mentions_log"

# ----------------------------------------------------------
# PROMPT TEMPLATES: Community Agent
# ----------------------------------------------------------
prompt_templates:
  community/signal-classifier-v2: |
    You are a B2B SaaS community monitoring classifier.

    Classify this social mention:
    PLATFORM: {{platform}}
    AUTHOR: {{author}} (followers/upvotes: {{influence_score}})
    TEXT: {{mention_text}}
    URL: {{post_url}}

    SIGNAL TYPES:
    - question: Someone is asking about the brand, product, or category
    - complaint: Someone expressing dissatisfaction (with their current solution, our product, or the category)
    - opportunity: Someone describing a problem/pain that indicates a potential sale
    - praise: Positive sentiment about the brand or product
    - mention: General reference with no strong sentiment or intent

    CLASSIFICATION:
    1. signal_type: [question | complaint | opportunity | praise | mention]
    2. sentiment: [positive | neutral | negative]
    3. urgency: [low | medium | high | critical]
       - critical: active complaint, public crisis signal, viral negative
       - high: complaint from high-influence account, question about enterprise/integrations
       - medium: general question, minor complaint
       - low: casual mention, praise
    4. response_recommended: [true | false]
    5. response_type: [draft_reply | escalate_human | monitor | ignore]
    6. competitive_signal: [true | false] — Is a competitor mentioned?
    7. influence_score: 1-10 based on reach and account authority
    8. key_takeaway: One sentence summarising what this signal means for the business

    Confidence score (0.0–1.0) for each classification.
    If confidence < 0.80, flag for human review.

  community/draft-response-v2: |
    You are a B2B SaaS community manager writing a response on {{platform}}.

    BRAND VOICE: "Direct, helpful, not salesy. We know our stuff. We don't oversell."

    MENTION CONTEXT:
    Original post: {{signal.original_text}}
    Signal type: {{signal.signal_type}}
    Sentiment: {{signal.sentiment}}
    Urgency: {{signal.urgency}}

    PLATFORM-SPECIFIC RULES:
    - LinkedIn: Professional tone, can be slightly warm. Max 500 chars for comments. No links in first line.
    - Twitter/X: Concise, can be witty. Max 280 chars. Can link to resources.
    - Reddit: More casual, community-native. No obvious marketing. Be genuinely helpful first.
    - Hacker News: Intellectual honesty. No marketing speak. Admit limitations if relevant.

    RESPONSE STYLE:
    - Always be genuinely helpful, not promotional
    - If answering a question: give the most useful answer, not the most complete
    - If addressing a complaint: acknowledge first, solve second
    - If praising: thank genuinely and briefly
    - Never lie or overstate — if you don't know, say so

    Output: { response_text, response_length_chars, link_to_include_if_any }

workflow_schema_version: "1.0"
agent_name: "paid-media-agent"
workflow_name: "paid-acquisition-campaign-automation"

trigger:
  type: event | schedule
  event:
    source: "new_campaign_launch_request | creative_refresh_request | budget_review_trigger"
    payload:
      trigger_type: enum[new_campaign, creative_test, budget_rebalance, weekly_optimization]
      campaign_id: string
  schedule:
    weekly_optimization: "0 9 * * MON"  # Monday morning budget review
    creative_refresh: "0 9 * * THU"     # Thursday creative check

input_schema:
  type: object
  required: [campaign_id, objective, budget_daily_usd]
  properties:
    campaign_id:
      type: string
      description: "CRM/Ad platform campaign ID"
    objective:
      type: enum[leads, conversions, traffic, brand_awareness, app_installs]
    budget_daily_usd:
      type: number
    platforms:
      type: array
      items: { enum: [google_ads, meta_ads, linkedin_ads, twitter_ads, tiktok_ads] }
    targeting:
      type: object
      properties:
        audience_definition: { type: string }
        age_range: { type: string }
        geo_targeting: { type: array, items: { string } }
        device_targeting: { type: array, items: { enum[desktop, mobile, tablet] } }
    ad_formats:
      type: array
      items: { enum[single_image, carousel, video, lead_form, collection, story] }
    key_messages:
      type: array
      items: { type: string }
      description: "The 2–3 core messages the campaign should communicate"
    cta:
      type: string
      description: "Primary call to action"
    landing_page_url:
      type: string
    competitor_context:
      type: array
      items: { type: string }
      description: "Competitor names to reference for differentiation messaging"

action_sequence:
  - id: paid_01
    name: "Pull Historical Campaign Performance"
    tool: "ad_platform_api"
    platforms: input.platforms
    metrics:
      google_ads: [impressions, clicks, ctr, cpc, conversions, cost, conversions_value, roas, search_impression_share]
      meta_ads: [impressions, reach, clicks, ctr, cpc, conversions, amount_spent, relevance_score, frequency]
      linkedin_ads: [impressions, clicks, ctr, cpc, conversions, cost, lead_quality_score]
    date_range: last_14_days
    comparison_period: previous_14_days
    on_failure: alert_and_proceed_with_partial
    output: campaign_performance_data

  - id: paid_02
    name: "Generate Ad Copy Variations"
    tool: "llm_generation"
    model: "claude-sonnet-4-20250514"
    prompt_ref: "prompts/paid/ad-copy-generation-v3.md"
    per_platform_tasks:
      google_ads:
        generate:
          headlines: { count: 6, each_max_chars: 30 }
          descriptions: { count: 4, each_max_chars: 90 }
          callouts: { count: 3, each_max_chars: 25 }
          sitelinks: { count: 4, each_max_chars: 25 }
        constraints:
          use_strict_dynamic_keyword_insertion: false
          no_pii_in_copy: true
          no_exaggerated_claims: true
      meta_ads:
        generate:
          primary_text: { count: 3, each_max_chars: 125 }
          headline_options: { count: 3, each_max_chars: 40 }
          descriptions: { count: 2, each_max_chars: 20 }
        constraints:
          no_direct_competitor_mentions: true
          image_text_limit_pct: 20
      linkedin_ads:
        generate:
          intro_text: { count: 3, each_max_chars: 150 }
          headlines: { count: 3, each_max_chars: 70 }
          cta_labels: { count: 3 }
        constraints:
          professional_tone: true
          industry_jargon_acceptable: true
    on_failure: escalate_human
    output: ad_copy_variations

  - id: paid_03
    name: "Generate Creative Brief for Visual Assets"
    tool: "llm_generation"
    model: "claude-sonnet-4-20250514"
    prompt_ref: "prompts/paid/creative-brief-v2.md"
    variables:
      campaign_objective: input.objective
      key_messages: input.key_messages
      platforms: input.platforms
      ad_formats: input.ad_formats
      cta: input.cta
    output_format:
      creative_brief_per_format: array
      each_brief:
        format: string
        platform: string
        visual_direction: string
        color_guidance: string
        text_overlay_guidance: string
        dimensions: string
        do_list: array
        dont_list: array
    on_failure: escalate_human
    output: creative_briefs

  - id: paid_04
    name: "Human Gate — Ad Copy and Creative Brief Review"
    tool: "approval_request"
    approver: "paid_media_manager_email"
    timeout_hours: 4
    include_outputs:
      - ad_copy_variations: paid_02.output
      - creative_briefs: paid_03.output
      - historical_performance: paid_01.output
    on_timeout: escalate_to_backup
    on_approval: proceed_to_launch
    on_rejection: return_with_feedback
    output: approved_creative_package

  - id: paid_05
    name: "Generate Performance Review + Budget Recommendations"
    tool: "llm_analysis"
    model: "claude-sonnet-4-20250514"
    prompt_ref: "prompts/paid/performance-review-v2.md"
    condition: "trigger.trigger_type in [weekly_optimization, budget_review_trigger]"
    variables:
      current_performance: paid_01.output
      date_range: last_7_days
      budget_daily: input.budget_daily_usd
      platform: input.platforms
    analysis_sections:
      - performance_summary: { top_metrics: [roas, cpc, conversion_rate, cost_per_lead] }
      - creative_performers: { by_variant, top_3, bottom_3 }
      - audience_segment_analysis: { by_targeting_group, performance_breakdown }
      - budget_reallocation_recommendation:
          formula: |
            # ROAS-based reallocation formula
            # 1. Calculate ROAS efficiency = actual_roas / target_roas
            # 2. High performers (>1.3x efficiency): increase budget by 20-30%
            # 3. Underperformers (<0.7x efficiency): decrease budget by 20-30%
            # 4. Floor: never reduce below $10/day (maintains learning)
            # 5. Ceiling: never exceed 3x original budget per ad set
          recommended_daily_budgets: object
          rationale: string
      - creative_test_recommendations: { what_to_test_next, hypothesis, success_metric }
      - next_week_actions: { priority_ordered: 5 }
    output: optimization_recommendations

  - id: paid_06
    name: "Generate Weekly Paid Media Report"
    tool: "report_generation"
    schedule: "0 9 * * MON"
    metrics:
      total_spend: sum
      total_impressions: sum
      total_clicks: sum
      blended_ctr: "clicks / impressions"
      blended_cpc: "spend / clicks"
      total_conversions: sum
      blended_cpa: "spend / conversions"
      blended_roas: "conversion_value / spend"
      platform_breakdown: group_by(platform)
      ad_set_breakdown: group_by(ad_set_name)
      creative_breakdown: group_by(creative_id)
      budget_utilization_pct: "actual_spend / scheduled_spend"
    output:
      slack:
        destination: "slack:#paid-media-ops"
        format: slack_blocks
        sections: [executive_summary, platform_performance, top_creatives, budget_status, recommended_actions]
      email:
        destination: input.output_recipients
        format: email_html
        subject: "Paid Media Weekly — {{date_range}}"
    output_format:
      roas_calculation: |
        # ROAS = Revenue Generated / Amount Spent
        # Example: $12,000 revenue from $3,000 ad spend = 4.0x ROAS
        # 
        # ROAS by Platform:
        # Google Ads: conversions_value / cost
        # Meta Ads: conversions_value / amount_spent
        # LinkedIn Ads: conversions_value / cost
        #
        # Target ROAS thresholds (B2B SaaS, varies by ACV):
        # SMB (ACV < $10k): 3.0-5.0x minimum
        # Mid-Market (ACV $10k-$100k): 2.0-3.5x minimum
        # Enterprise (ACV > $100k): 1.5-2.5x minimum
        #
        # CAC Ratio Check:
        # blended_cac should be < target_cac_from_finance
        # CAC = spend / new_customers_acquired