tweet-digest

type	Skill
name	Tweet Digest
category	basics
description	Account-based digest of recent tweets from tracked X/Twitter accounts. Sibling to fetch-tweets (keyword) and tweet-roundup (topic).
var
tags	["social"]
requires	["TWITTER_API_KEY","XAI_API_KEY?"]

${var} — Optional. If set, restrict to that single account (or topic filter). If empty, processes every account in memory/topics/tracked-accounts.yml.

This skill is the account-based sibling in the tweet-fetcher family:

Skill	Axis	Input
fetch-tweets	keyword / query	${var} is the search query
tweet-roundup	topic	groups recent tweets by topic
tweet-digest (this)	account	reads a list of handles from memory/topics/tracked-accounts.yml

Use this skill when you care about "what did these specific people post" rather than "what's anyone saying about X."

Voice

If soul/SOUL.md and soul/STYLE.md are populated, read both and match the operator's voice for the per-tweet one-sentence takes. If they are empty templates or absent, write the takes in a clear, direct, neutral tone — no hedging, no editorializing beyond what the tweet itself says.

Config

Reads memory/topics/tracked-accounts.yml. If the file is missing or accounts: [], log TWEET_DIGEST_NO_CONFIG and exit (no notification).

# memory/topics/tracked-accounts.yml
accounts:
  - handle: vitalikbuterin
    why: ethereum core thinking
  - handle: balajis
    why: macro + tech narratives
  - handle: <handle>
    why: <one-line reason — used to give the digest grouping context>

The why field is optional but useful — it's the grouping/context label in step 2.

Steps

Read memory/MEMORY.md for context and the last 2 days of memory/logs/ to dedup recent tweets.

1. Fetch recent tweets per account

For each handle in the config (or just the one from ${var} if set):

Path A - twitterapi.io (primary). /user/last_tweets returns structured tweet objects (exact engagement counts, real permalinks, parsed fields) in ~700ms - no fabrication risk. It has no server-side date filter, so keep the last 3 days client-side on .createdAt. Auth via ./secretcurl with the literal {TWITTER_API_KEY} placeholder (never $TWITTER_API_KEY; see CLAUDE.md -> Network & Secrets):

SINCE=$(date -u -d '3 days ago' +%Y-%m-%d 2>/dev/null || date -u -v-3d +%Y-%m-%d)
HTTP=$(./secretcurl -m 30 -s -o /tmp/tw-td.json -w '%{http_code}' -G "https://api.twitterapi.io/twitter/user/last_tweets" \
  --data-urlencode "userName=$HANDLE" -H "X-API-Key: {TWITTER_API_KEY}")
echo "twitterapi http=$HTTP"
# on HTTP 200: last-3-day originals (createdAt is Twitter native format; strptime normalizes to a date), skip replies/RTs
jq -r --arg since "$SINCE" '
  .data.tweets[]
  | select((.isReply // false) | not)
  | (try (.createdAt | strptime("%a %b %d %H:%M:%S %z %Y") | strftime("%Y-%m-%d")) catch (.createdAt[0:10])) as $d
  | select($d >= $since)
  | [.author.userName, $d, .likeCount, .retweetCount, .replyCount, .url, .text] | @tsv' /tmp/tw-td.json

On HTTP=200 with parsed rows, take the 5 most interesting or substantive tweets for that handle; paginate with &cursor=<next_cursor> only if you need older in-window tweets.

Path B - xAI Grok x_search (fallback). Only if a handle's Path A returned non-2xx, empty, or timed out (or TWITTER_API_KEY is unset). Call Grok's x_search in-run with ./secretcurl (the literal {XAI_API_KEY} placeholder - never $XAI_API_KEY; see CLAUDE.md -> Network & Secrets). Capture the HTTP status and print http=<code> before parsing:

PROMPT="Search X for the latest tweets from ${HANDLE} in the last 3 days. Return the 5 most interesting or substantive tweets. For each: full text, date, direct link (https://x.com/${HANDLE}/status/ID). Skip retweets of others."
jq -n --arg p "$PROMPT" '{model:"grok-4-1-fast", input:[{role:"user",content:$p}], tools:[{type:"x_search"}]}' > /tmp/xai-td.json
HTTP=$(./secretcurl -m 60 -s -o /tmp/xai-td-out.json -w '%{http_code}' -X POST "https://api.x.ai/v1/responses" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer {XAI_API_KEY}" \
  -d @/tmp/xai-td.json)
echo "http=$HTTP"

Then parse /tmp/xai-td-out.json for the tweets. If neither TWITTER_API_KEY nor XAI_API_KEY is set, log TWEET_DIGEST_NO_KEY: skill requires TWITTER_API_KEY or XAI_API_KEY and exit (no notification). On a non-2xx http, a --max-time timeout, or a 200 with an empty body on both paths, record the real reason (http-<code> / timeout / empty) and skip that handle - never blame a "sandbox".

Dedup: grep the last 2 days of memory/logs/ for https://x.com/ URLs already reported. Drop any candidate URL that's already been seen.

2. Group by theme, not by account

Walk the candidate set across all accounts. Identify 2–4 themes (e.g. "L2 design decisions", "macro / rates", "AI model releases", "regulation"). Each tweet maps to one theme. A why: label from the config can seed theme naming when an account is a single-topic feed.

3. Write a one-sentence take per notable tweet

The take states what the tweet says, not your opinion of it. Voice per the Voice section above.

4. Format and notify

Send via ./notify (under 4000 chars):

*Tweet Digest — ${today}*

*Theme: <theme>*
@handle: <one-sentence summary> — [link](url)
@handle: <one-sentence summary> — [link](url)

*Theme: <theme>*
...

5. Log

Append to memory/logs/${today}.md with the tweet URLs reported (so the next run can dedup). If no notable tweets found across all tracked accounts: log TWEET_DIGEST_OK and end (no notification).

Fetching - in-run, no prefetch

Auth'd calls run in-run via ./secretcurl with a literal {ENV} placeholder - twitterapi.io ({TWITTER_API_KEY}, primary) and X.AI Grok ({XAI_API_KEY}, fallback); see step 1 and CLAUDE.md -> Network & Secrets. There is no prefetch/cache step - the retired .xai-cache/ + scripts/prefetch-xai.sh pattern no longer exists; do not reference it.

Environment Variables

• TWITTER_API_KEY - primary. twitterapi.io key (X-API-Key header) for structured tweet fetches via /user/last_tweets.
• XAI_API_KEY - optional fallback. X.AI API key for Grok's x_search tool when twitterapi.io is unavailable.