Mention Radar

${var} — Comma-separated project names to track (e.g. "MyApp, my-lib"). If empty, derives targets from MEMORY.md and memory/topics/projects.md.

Read memory/MEMORY.md for current project status. Read the last 3 days of memory/logs/ to avoid re-surfacing already-noted mentions.

Steps

1. Define the targets.

   • If ${var} is set: parse it as a comma-separated list of project names.
   • Otherwise: scan memory/MEMORY.md (goals, active topics) and memory/topics/projects.md (if it exists) for the operator's active projects. A target needs at least a name; collect a site/domain and a GitHub owner/repo too when known.
   • Cap at 6 targets — prefer the most active ones.
   • If zero targets can be derived: log MENTION_RADAR_SKIP: no projects configured — set var or add projects to memory/topics/projects.md and stop. No notification.

   For each target, build search terms:

   • The exact project name in quotes (e.g. "MyApp" site:x.com OR site:reddit.com OR site:news.ycombinator.com)
   • The domain if known (e.g. "myapp.xyz")
   • The repo if known (e.g. site:github.com owner/myapp)

2. Search for external mentions. X/Twitter is fetched via the X.AI Responses API (primary); the rest of the public web (Reddit, Farcaster, blogs, newsletters, GitHub Discussions, HN, Product Hunt) goes through WebSearch, which is also the last-resort fallback for X itself. Derive the operator's handle from soul/SOUL.md if present (call it $OPERATOR) so you can exclude their own posts.

   Path A — X.AI API (primary, X/Twitter mentions). For each target, ask Grok's x_search who is talking about the project on X. See the Fetching contract below — attempt this whenever the key is present, set the Bash tool timeout to ≥180000, and capture the HTTP status. Use a unique tmp filename per target if you loop (e.g. /tmp/xai-mr-$SLUG.json). $NAME/$DOMAIN/$REPO come from the target built in step 1 ($DOMAIN/$REPO may be empty — leave them out if so):

   FROM_DATE=$(date -u -d "7 days ago" +%Y-%m-%d 2>/dev/null || date -u -v-7d +%Y-%m-%d)
   TO_DATE=$(date -u +%Y-%m-%d)
   PROMPT="Search X for posts by OTHER people mentioning the project \"${NAME}\" (also its site ${DOMAIN} and repo ${REPO} when given), posted between ${FROM_DATE} and ${TO_DATE}. Exclude posts by the operator @${OPERATOR} and by the project's own accounts. For each mention return: @handle, the full post text, date, exact engagement counts (likes, retweets, replies; 0 if unknown), the poster's approximate follower count if visible, and the direct link https://x.com/handle/status/ID. Prioritize people discovering it for the first time, asking confused questions, hitting friction (setup/docs/missing feature), comparing it to a competitor, or requesting a feature. Return a numbered list; if nobody is talking about it, say so explicitly."
   jq -n --arg p "$PROMPT" --arg fd "$FROM_DATE" --arg td "$TO_DATE" \
     '{model:"grok-4.7", input:[{role:"user",content:$p}], tools:[{type:"x_search",from_date:$fd,to_date:$td}]}' \
     > /tmp/xai-mr-payload.json
   HTTP=$(./secretcurl -s -o /tmp/xai-mr.json -w '%{http_code}' --max-time 150 -X POST "https://api.x.ai/v1/responses" \
     -H "Content-Type: application/json" \
     -H "Authorization: Bearer {XAI_API_KEY}" \
     -d @/tmp/xai-mr-payload.json)
   echo "xai http=$HTTP bytes=$(wc -c </tmp/xai-mr.json)"

   On HTTP=200 with a non-empty body, parse /tmp/xai-mr.json with jq -r '.output[] | select(.type == "message") | .content[] | select(.type == "output_text") | .text' and feed the X mentions into categorization (step 4). Record X_SOURCE=api.

   Path B — WebSearch (broader web + X fallback). Always use WebSearch for the non-X surfaces — Reddit, Farcaster, personal blogs, newsletters, GitHub Discussions, HN, Product Hunt:

   • Try both brand name and URL variants
   • Time-box to last 7 days where the search engine supports it
   • Skip results from the operator's own accounts and the project's own repos

   WebSearch is also the fallback for X/Twitter, but only when Path A truly failed (key-unset, http-<code>, empty, or timeout — record the real reason per the Fetching contract, never "XAI_API_KEY unavailable" when the key was set). On the X fallback query site:x.com "<project name>" after:${FROM_DATE}; note in the log that X results came from WebSearch (lower quality) and set X_SOURCE=websearch.

3. Also check GitHub network signals for each target with a known repo:

   gh api repos/OWNER/REPO --jq '{stars: .stargazers_count, forks: .forks_count, watchers: .watchers_count}'

   Skip any repo that 404s (private or not yet public). Compare to the last log entry to compute deltas. If no prior data, record as baseline.

4. Categorize each mention found:

   • Discovery — person found the project for the first time, sharing it, impressed ("this is cool", star notification, share)
   • Confusion — person unclear on what it does, asking questions, mischaracterizing it
   • Friction — person ran into a problem (setup, docs, missing feature)
   • Competitor comparison — mentioned alongside or against a competing project
   • Feature request / wish — explicit ask for something missing
   • Press / newsletter — cited in a publication or digest

5. Identify engagement opportunities. Flag any mention where:

   • The person is confused and a 1-tweet clarification would help
   • A feature request aligns with what's being built
   • A competitor comparison is wrong or incomplete
   • A high-follower account discovered the project (high-leverage reply opportunity)

6. Format the output (under 4000 chars):

   *Mention Radar — ${today}*
   
   {PROJECT NAME, uppercased}
   - [source] — [what they said] — [category]
   ...
   (one section per target)
   
   ENGAGEMENT OPPORTUNITIES
   - [handle/source]: [why worth replying]
   
   QUIET: [project] — no external mentions found

   Use QUIET: [project] for any project with zero external mentions this cycle. Skip GitHub-only star delta if it's less than 5 — only mention notable jumps.

7. Only notify if there's signal. Skip notification if ALL projects are quiet and no GitHub deltas > 5 stars. Log MENTION_RADAR_QUIET instead.

8. Send via ./notify if there's anything worth surfacing.

9. Log to memory/logs/${today}.md:

   ### mention-radar
   - **{project}:** [N mentions / QUIET]
   (one line per target)
   - **Top find:** [best mention in one line, or "none"]
   - **Engagement opps:** [N flagged, or 0]
   - **Notification sent:** yes/no