Claude Cowork × MCP Server Integration Guide — Building a Cross-Service Automation Ecosystem with Slack, Notion & GitHub

# skills/morning-brief/SKILL.md (excerpt)
 
## Data Sources
- GitHub (masakihirokawa/claudelab.net): commits in last 24h, open PRs, issues due this week
- Notion (Projects database): tasks with status "In Progress" or "Blocked"
- Notion (Content Calendar): articles scheduled for today
 
## Compilation Rules
- Lead with anything marked "Blocked" — these need immediate attention
- For PRs: show author, branch name, days open, and review status
- For Issues: include title, assignee, milestone, and days until due
- Keep the total message under 40 lines for readability
 
## Output
Post to Slack #morning-brief in this format:
  📊 Morning Brief — {date}
  🚨 Blockers: {list or "None"}
  📌 Open PRs ({count}): {brief list}
  📋 Due This Week ({count}): {brief list}
  ✍️ Publishing Today: {article titles}

# Alert routing logic within a skill
ALERT_TYPE=$(classify_alert "$ALERT_CONTENT")
 
case $ALERT_TYPE in
  "critical")
    # Production down, data loss, security incident
    slack_mcp post_message channel=#incidents text="🚨 CRITICAL: $ALERT_CONTENT" mention=@channel
    slack_mcp create_thread channel=#incidents text="Auto-diagnosed issue: $(diagnose $ALERT_CONTENT)"
    ;;
  "warning")
    # CI failure, elevated error rate, approaching limits
    slack_mcp post_message channel=#alerts text="⚠️ WARNING: $ALERT_CONTENT"
    ;;
  "info")
    # Routine completions, milestone achievements
    slack_mcp post_message channel=#logs text="ℹ️ $ALERT_CONTENT"
    ;;
esac

# weekly-digest skill
 
## Process
1. Search Slack for messages with 3+ reactions posted in the last 7 days across key channels
2. Include thread starters for high-engagement threads (5+ replies)
3. Summarize each item in 1-2 sentences
4. Post the compiled digest to #weekly-highlights every Friday at 5 PM

# weekly-report skill
 
## Inputs
- Google Analytics weekly export (CSV) in workspace analytics/ folder
- Slack #project-updates channel messages from this week
- GitHub repository metrics (commits, PRs, issues)
 
## Processing
1. Parse GA CSV and extract: pageviews, unique users, bounce rate, avg session duration, top 5 pages
2. Compute week-over-week changes (current vs. previous 7-day period)
3. Extract 3-5 highlights from Slack #project-updates (highest-reaction messages)
4. Summarize GitHub activity: lines changed, PRs merged, issues closed
 
## Notion Output
Create a new page in the "Weekly Reports" database with:
  Title: [YYYY/WW] Weekly Report — {date range}
  Properties:
    - Week: {week number}
    - Total Pageviews: {number}
    - Total Users: {number}
    - WoW Growth: {percentage}
    - PRs Merged: {count}
    - Issues Closed: {count}
  Body sections:
    - Key Metrics (prose summary of the numbers)
    - Highlights (3-5 bullet points from Slack)
    - Blockers and Risks
    - Next Week Priorities (inferred from open issues and Slack context)

# Conceptual: pulling product context from Notion before generating content
def get_brand_guidelines() -> str:
    """Fetch current brand voice guidelines from Notion"""
    page = notion_mcp.get_page(page_id="BRAND_GUIDELINES_PAGE_ID")
    return extract_text_content(page)
 
def get_competitor_analysis() -> dict:
    """Pull structured competitor data from a Notion database"""
    return notion_mcp.query_database(
        database_id="COMPETITOR_DB_ID",
        sorts=[{"property": "Last Updated", "direction": "descending"}],
        filter={"property": "Status", "select": {"equals": "Active"}}
    )

# github-to-notion-sync skill
 
## Trigger
Run hourly during working hours (9 AM - 10 PM JST)
 
## Process
1. Fetch GitHub Issues updated in the last 60 minutes
2. For each issue:
   a. Check if a corresponding Notion task exists (match by issue number)
   b. If not: create a new page in the "Dev Tasks" database
   c. If yes: update status, last-modified date, and any label changes
3. For Notion tasks marked "Done": check if the corresponding GitHub issue is closed
4. Report sync summary to Slack #dev (message if discrepancies found, silent if clean)
 
## Mapping
- GitHub "open" → Notion "In Progress" (if assignee set) or "Backlog"
- GitHub "closed" → Notion "Done"
- GitHub labels → Notion multi-select tags

# pr-review skill (triggered by schedule task checking for new PRs)
OPEN_PRS=$(github_mcp list_pull_requests repo=claudelab.net state=open)
UNREVIEWED=$(filter_prs_without_bot_review "$OPEN_PRS")
 
for PR_NUMBER in $UNREVIEWED; do
  DIFF=$(github_mcp get_pull_request_diff pr_number=$PR_NUMBER)
  FILES=$(github_mcp list_pull_request_files pr_number=$PR_NUMBER)
 
  # Claude analyzes the diff with specific focus areas
  REVIEW=$(analyze_pr_diff "$DIFF" --checks "
    - Security: check for hardcoded credentials, SQL injection risks, XSS vectors
    - Performance: identify N+1 queries, unnecessary re-renders, missing indexes
    - Readability: flag unclear variable names, missing comments on complex logic
    - Test coverage: note untested paths in changed files
  ")
 
  # Post the review as a comment (not a blocking review, just informational)
  github_mcp create_review \
    pr_number=$PR_NUMBER \
    body="## 🤖 Automated Pre-Review\n\n$REVIEW\n\n*This is an automated analysis. Human review is still required before merging.*" \
    event="COMMENT"
done

# release-notes skill
 
## Trigger
Run when a new tag matching v*.*.* appears in the repository
 
## Process
1. Get all PRs merged since the previous release tag
2. Group PRs by label: Features / Bug Fixes / Performance / Documentation / Dependencies
3. Generate a human-readable changelog (not just a list of PR titles)
4. Post the changelog to:
   a. GitHub Release page (as release notes)
   b. Notion "Releases" database (as a permanent record)
   c. Slack #announcements (with appropriate emoji and celebration for major versions)

# Task name: claudelab-morning-brief
# Cron: 45 8 * * 1-5 (8:45 AM JST, weekdays)
 
Load the skill file at _skills/morning-brief/SKILL.md
and execute Steps 0 through 5 completely. Do not skip any step.

# CI monitoring skill — runs hourly via schedule task
 
## Step 1: Fetch CI Status
LATEST_RUN=$(github_mcp list_workflow_runs repo=claudelab.net branch=main limit=1)
STATUS=$(extract_field "$LATEST_RUN" "conclusion")
RUN_ID=$(extract_field "$LATEST_RUN" "id")
 
## Step 2: Branch on Status
 
### If failure:
# Get the full logs to understand what broke
ERROR_LOGS=$(github_mcp get_workflow_run_logs run_id=$RUN_ID)
 
# Claude analyzes the logs and generates a diagnosis
DIAGNOSIS=$(analyze_ci_failure "$ERROR_LOGS")
 
# Alert Slack with actionable context
slack_mcp post_message \
  channel=#alerts \
  text="🚨 CI Failure on main\n\n*Diagnosis:* $DIAGNOSIS\n\n*Run:* github.com/...actions/runs/$RUN_ID"
 
# Create an incident record in Notion
notion_mcp create_page \
  database=incidents \
  title="CI Failure — $(date '+%Y-%m-%d %H:%M')" \
  content="$DIAGNOSIS\n\nFull logs: [Run $RUN_ID]"
 
### If success:
# Update the deployment log in Notion (no Slack notification for routine successes)
notion_mcp update_page \
  page=deployment-log \
  property="Last Successful Build" \
  value="$(date)"
 
echo "✅ CI passed — deployment log updated"

# weekly-dashboard-update skill — runs every Friday at 6 PM
 
## Data Collection (parallel where possible)
 
### GitHub metrics (this week):
- Total commits across all repositories
- Pull requests merged
- Issues closed
- Issues opened
- Deployment count (from workflow run history)
 
### Slack metrics (this week):
- Messages sent across tracked channels
- Top 3 posts by reaction count (with link and reaction total)
- Thread activity in #important
 
### Notion metrics (this week):
- Tasks moved to "Done" status
- New tasks created
- Tasks that are overdue
 
### Content metrics (this week):
- Parse _updated_article_log/ for article count by site and category
 
## Aggregation
- Compare all metrics to the previous week (compute percentage change)
- Flag any metric that changed by more than 20% in either direction
 
## Dashboard Update
- Overwrite all numeric properties in the Notion "Weekly KPI Dashboard" page
- Append a new row to the "Weekly History" database table
- Post a concise summary (5-7 bullets) to Slack #management
 
## Output Format for Slack
  📊 Weekly Dashboard Updated — {date}
  GitHub: {X commits, Y PRs merged, Z issues closed}
  Content: {N articles published across 4 sites}
  Notion: {M tasks completed, K tasks created}
  Notable: {any metric with >20% change, with direction arrow}

# incident-response skill
 
## Inputs
Triggered by: CI failure, error rate spike, user-reported issue, or scheduled health check failure
 
## Step 1: Classify the Incident
Based on error type, affected service, and time of day, classify as:
- P1 (Critical): production down or data loss
- P2 (High): significant degradation affecting users
- P3 (Medium): non-critical functionality affected
- P4 (Low): cosmetic issue or minor edge case
 
## Step 2: Create Incident Record
Create a new page in the Notion "Incidents" database:
  - Title: [P{level}] Brief description — {timestamp}
  - Status: "Investigating"
  - Affected Service: {from input}
  - First Detected: {timestamp}
  - Severity: P{1-4}
 
## Step 3: Route Notification
- P1: Post to Slack #incidents with @channel mention, link to Notion record
- P2: Post to Slack #alerts with @here mention
- P3-4: Post to Slack #logs silently
 
## Step 4: Generate Initial Diagnosis
If logs are available, analyze them and add a "Initial Diagnosis" section to the Notion incident page.
 
## Step 5: Update Status
When the incident is resolved (detected by subsequent health check passing):
  - Update Notion incident status to "Resolved"
  - Post resolution summary to the Slack thread
  - Calculate and record MTTR (mean time to recovery)

# Add connection probing with exponential backoff
MAX_RETRIES=3
RETRY_COUNT=0
 
probe_connector() {
  local connector=$1
  timeout 10 ${connector}_mcp ping 2>/dev/null
  return $?
}
 
while [ $RETRY_COUNT -lt $MAX_RETRIES ]; do
  if probe_connector "slack"; then
    echo "✅ Slack MCP connected"
    break
  fi
  RETRY_COUNT=$((RETRY_COUNT + 1))
  WAIT_TIME=$((2 ** RETRY_COUNT))
  echo "⚠️ Connection failed. Retry $RETRY_COUNT/$MAX_RETRIES in ${WAIT_TIME}s..."
  sleep $WAIT_TIME
done
 
if [ $RETRY_COUNT -eq $MAX_RETRIES ]; then
  echo "❌ Slack MCP unavailable after $MAX_RETRIES retries"
  exit 1
fi

# Discover available tools for a connector
notion_mcp list_tools 2>/dev/null
# Expected output might show: create_page, append_block_children, update_page, etc.
 
# If the old tool name no longer exists, find the replacement
notion_mcp list_tools | grep -i "create"

# Respectful bulk operations with adaptive throttling
post_batch_to_notion() {
  local items=("$@")
  local count=0
  local errors=0
 
  for item in "${items[@]}"; do
    if notion_mcp create_page database=$DB_ID content="$item"; then
      count=$((count + 1))
      sleep 0.4  # Stay comfortably under 3 req/s
    else
      errors=$((errors + 1))
      echo "⚠️ Failed to create page for: $item"
      sleep 2  # Back off on error
    fi
  done
 
  echo "Batch complete: $count succeeded, $errors failed"
}

# token-health-check skill (runs every Monday at 9 AM)
 
1. Read the connector inventory document from Notion "Infrastructure" page
2. For each token, calculate days until expiry based on creation date and configured TTL
3. Generate a report:
   - 🔴 Expired or expiring within 3 days: URGENT rotation required
   - 🟡 Expiring within 7 days: Schedule rotation this week
   - 🟢 Valid for 30+ days: No action needed
4. If any 🔴 or 🟡 items exist: Post to Slack #dev-infra with specific tokens named
5. Log the health check result to Notion "Infrastructure" > "Token Health" table

# Track completion of each step explicitly
STEPS_COMPLETED=()
 
# Step 1: Fetch data
if GITHUB_DATA=$(github_mcp get_recent_activity); then
  STEPS_COMPLETED+=("github_fetch")
else
  echo "❌ GitHub fetch failed — aborting to avoid partial state"
  exit 1
fi
 
# Step 2: Update Notion
if notion_mcp update_page page=dashboard data="$GITHUB_DATA"; then
  STEPS_COMPLETED+=("notion_update")
else
  echo "❌ Notion update failed — skipping Slack notification to avoid false positive"
  # Don't exit — log and continue with reduced functionality
fi
 
# Step 3: Post to Slack (only if Notion succeeded)
if [[ " ${STEPS_COMPLETED[@]} " =~ " notion_update " ]]; then
  slack_mcp post_message channel=#reports text="Dashboard updated: $SUMMARY"
  STEPS_COMPLETED+=("slack_notify")
fi
 
echo "Completed steps: ${STEPS_COMPLETED[*]}"

# Anti-pattern: blind write
slack_mcp post_message channel=#reports text="Weekly report ready"
 
# Better pattern: check-then-write
TODAY=$(date +%Y-%m-%d)
EXISTING=$(slack_mcp search_messages query="Weekly report ready" in=#reports after=$TODAY)
 
if [ -z "$EXISTING" ]; then
  slack_mcp post_message channel=#reports text="Weekly report ready — $TODAY"
else
  echo "ℹ️ Report already posted today — skipping duplicate"
fi

{
  "timestamp": "2026-03-31T09:15:00+09:00",
  "task": "morning-brief",
  "step": "github_fetch",
  "status": "success",
  "duration_ms": 342,
  "items_fetched": 12,
  "context": {
    "repo": "claudelab.net",
    "branch": "main",
    "since": "2026-03-30T09:15:00+09:00"
  }
}

send_daily_report() {
  local REPORT_CONTENT=$1
 
  # Primary: Slack
  if slack_mcp post_message channel=#daily-reports text="$REPORT_CONTENT" 2>/dev/null; then
    echo "✅ Report sent via Slack"
    return 0
  fi
 
  echo "⚠️ Slack unavailable — trying Notion fallback"
 
  # Secondary: Notion
  if notion_mcp create_page database=daily-reports content="$REPORT_CONTENT" 2>/dev/null; then
    echo "✅ Report saved to Notion"
    return 0
  fi
 
  echo "⚠️ Notion unavailable — saving to local log"
 
  # Tertiary: local file
  WS="$(ls -d /sessions/*/mnt/Dolice\ Labs 2>/dev/null | head -1)"
  echo "$(date): $REPORT_CONTENT" >> "$WS/_logs/report_fallback_$(date +%Y-%m-%d).txt"
  echo "✅ Report saved to local fallback log"
}