dcurlewis/.claude/skills/slack-fetch

Fetch Slack channel and DM messages using MCP Slack tools. Produces one markdown file per channel/DM in Raw-Materials/Slack/ for subsequent processing by /slack.

Arguments

• No arguments = daily mode (incremental from last sync, or 24h fallback)
• weekly = forces 7-day lookback for all channels
• channel:#name = single channel debug mode

Parse $ARGUMENTS to determine mode.

Step 1: Read State

Read Scripts/sync_config.json and extract:

• All enabled channels from slack.channels (both channels and DMs)
• Per-channel last-synced timestamps from slack.last_synced_channels

Compute the oldest Unix timestamp (seconds) for each channel:

• If last_synced_channels.{id} exists: parse that ISO timestamp to Unix seconds
• If no per-channel timestamp: use now - 86400 (24h fallback)
• If weekly mode: force now - 604800 (7 days) for all channels

For channel:#name mode: filter to only the matching channel and use the same timestamp logic.

Store now as a reference timestamp for state updates later.

Step 2: Mentions Discovery

Spawn a single Haiku sub-agent to discover channels where you were active but that are not in the monitored list.

Agent prompt:

Search Slack for recent activity by the user (user ID: <YOUR_SLACK_USER_ID>) using Slack MCP search tools.

Run two searches (IMPORTANT: must use response_format: "detailed" because only the detailed format includes channel IDs):

1. query: "from:<@YOUR_SLACK_USER_ID> after:YYYY-MM-DD" (yesterday's date) with include_context: false, response_format: "detailed", limit: 20
2. query: "to:<@YOUR_SLACK_USER_ID> after:YYYY-MM-DD" (yesterday's date) with include_context: false, response_format: "detailed", limit: 20

For each search, if the response includes a pagination cursor, fetch the next page as well (up to 2 pages per search, i.e. up to 40 results each).

From all results, extract channel IDs from the Channel: ... (ID: ...) lines in each result.

Filter out:

• Any channel IDs that are in this monitored list: [list all channel IDs from Step 1]
• Any bot DMs (participants named "Google Calendar", "Slackbot", or any name that looks like a bot/integration rather than a person)

Return a JSON array of objects: [{"id": "C...", "name": "channel-name-or-DM-description"}, ...] If no new channels found, return an empty array: [] Do NOT write any files. Only return the JSON result.

Wait for this agent to complete. Parse the discovered channels (cap at 10 max). Discovered channels always use oldest = now - 86400 regardless of mode.

Combine: full export list = monitored channels + discovered channels.

Skip this step entirely in channel:#name mode.

Step 3: Batched Parallel Export

Process the full channel list in batches of 8 channels. For each batch, spawn all agents in parallel, then wait for all to complete before starting the next batch. Pause 3 seconds between batches.

For each channel, spawn a Haiku sub-agent with this prompt:

Export Slack channel "{name}" (ID: {id}).

Call the Slack MCP read_channel tool with:

• channel_id: "{id}"
• oldest: "{oldest_unix_timestamp}"
• limit: 100
• response_format: "concise"

If the response includes a next_cursor, make additional calls with that cursor until all messages are fetched or you reach 500 messages total.

If you receive a rate_limited error, wait 5 seconds and retry once.

Format the output as a markdown file with this structure:

# Slack Export: {name}
*Fetched: {ISO_NOW} | Since: {oldest_ISO_date} | Messages: {count}*

---

**{sender}** ({timestamp}):
{message body}

**Thread Replies:**
  - **{sender}**: {reply}

If there are thread replies in the response, include them nested under the parent message.

If no messages were found since the oldest timestamp, use this format:

# Slack Export: {name}
*Fetched: {ISO_NOW} | Since: {oldest_ISO_date} | Messages: 0*

---

No new messages.

Write the file to: Raw-Materials/Slack/{YYYYMMDD}-{safe_name}.md where {YYYYMMDD} is today's date and {safe_name} is the channel name with spaces replaced by hyphens and special characters removed. For DMs, use the format DM-{PersonName}.

After writing, respond with a single line: OK:{message_count} or ERROR:{description}

Collect results from all agents, tracking total messages and any errors.

Step 4: Update State

After all batches complete, read Scripts/sync_config.json again (to avoid stale reads), then update:

• slack.last_synced = current ISO timestamp (UTC)
• slack.last_synced_channels.{id} = current ISO timestamp for each monitored channel that was exported (not discovered channels)
• slack.total_messages = previous value + total messages fetched this run

Write the updated JSON back to Scripts/sync_config.json with proper formatting (2-space indent).

Step 5: Report

Output a brief summary:

/slack-fetch complete
  Mode: daily|weekly|channel
  Channels exported: {monitored_count} monitored + {discovered_count} discovered = {total} total
  Files written: {count} (Raw-Materials/Slack/)
  Messages fetched: {total_messages}
  Errors: {error_count}

If there were errors, list each one.

Error Handling

• If a sub-agent returns an error for a channel, log it but continue with remaining channels
• If a DM ID (D...) is rejected by read_channel, note it in the report and skip that DM
• If the mentions discovery agent fails, proceed with only the monitored channels
• Never let a single channel failure abort the entire export