thumbgate 0.9.10 → 0.9.11

package/scripts/social-post-hourly.js

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * social-post-hourly.js → now "social-post-daily.js" in practice
+ *
+ * Generates ONE quality social post per day and publishes via Zernio
+ * to LinkedIn, X/Twitter, and TikTok (text-friendly platforms).
+ *
+ * Strategy based on research of top SaaS companies (Linear, Vercel, Supabase,
+ * PostHog, Cursor, Raycast, Cal.com):
+ * - 1 post/day, not 24. Quality over volume.
+ * - Rotate 7 content angles across the week (not 4 recycled hourly).
+ * - Content ratio: 30% educational, 25% product demo, 25% community, 20% hot takes.
+ * - NO Reddit auto-posting (ban risk). Reddit engagement via reply-monitor only.
+ * - NO Dev.to auto-posting (counterproductive at high volume).
+ *
+ * Runs daily via CI (.github/workflows/social-engagement-hourly.yml at 2pm UTC).
+ *
+ * Usage:
+ *   node scripts/social-post-hourly.js            # publish for real
+ *   node scripts/social-post-hourly.js --dry-run   # preview only
+ */
+
+require('dotenv').config();
+
+const { generateWeeklyStatsPost } = require('./daily-digest');
+const { publishPost, getConnectedAccounts } = require('./social-analytics/publishers/zernio');
+
+// Platforms that support text-only posts.
+// Reddit EXCLUDED — engagement only via reply-monitor, not auto-posting.
+// Instagram EXCLUDED — requires media.
+// TikTok EXCLUDED — requires video.
+const TEXT_PLATFORMS = new Set(['linkedin', 'twitter']);
+
+// 7 angles, one per day of the week (Monday=0 through Sunday=6)
+// Ratio: 2 educational, 2 product, 2 hot-take/community, 1 tip
+const DAILY_ANGLES = [
+  'horror-story',    // Monday: "This AI PR would have broken production"
+  'educational',     // Tuesday: Teach a concept (context engineering, gate patterns)
+  'product-demo',    // Wednesday: Specific feature highlight with concrete example
+  'hot-take',        // Thursday: Contrarian opinion about AI coding agents
+  'community',       // Friday: Highlight a user, contributor, or community discussion
+  'tip',             // Saturday: Quick actionable tip
+  'stats',           // Sunday: Weekly build-in-public numbers
+];
+
+function getTodayAngle() {
+  const day = new Date().getUTCDay(); // 0=Sun, 1=Mon, ..., 6=Sat
+  // Remap: Mon=0, Tue=1, ..., Sun=6
+  const idx = day === 0 ? 6 : day - 1;
+  return DAILY_ANGLES[idx];
+}
+
+function generatePost(angle) {
+  const { post, stats } = generateWeeklyStatsPost({ periodDays: 1 });
+  const REPO = 'https://github.com/IgorGanapolsky/ThumbGate';
+
+  switch (angle) {
+    case 'horror-story': {
+      const gate = stats.topGate || 'force-push prevention';
+      return [
+        `A Claude Code agent tried to force-push to main today.`,
+        '',
+        `The "${gate}" gate caught it before execution. No rollback needed, no incident, no Slack panic.`,
+        '',
+        `Pre-action gates > post-mortem reviews.`,
+        '',
+        `ThumbGate is open source: ${REPO}`,
+      ].join('\n');
+    }
+
+    case 'educational':
+      return [
+        'Context engineering vs prompt engineering for AI agents:',
+        '',
+        'Prompt engineering: "Please don\'t force-push to main"',
+        'Context engineering: Agent physically cannot force-push because a gate blocks it',
+        '',
+        'One is a suggestion. The other is enforcement.',
+        '',
+        'The agents that work reliably in production use both — but enforcement is what prevents the 2am incidents.',
+      ].join('\n');
+
+    case 'product-demo':
+      return [
+        'How ThumbGate works in 30 seconds:',
+        '',
+        '1. Agent tries to run a tool call',
+        '2. PreToolUse hook intercepts it',
+        '3. Call is checked against prevention rules',
+        '4. If it matches a known-bad pattern → blocked',
+        '5. Agent tries a different approach',
+        '',
+        'Rules are generated from your thumbs-down feedback. The system learns from your corrections.',
+        '',
+        `Try it: npx thumbgate init`,
+      ].join('\n');
+
+    case 'hot-take':
+      return [
+        'Unpopular opinion: CLAUDE.md files are not enough to make AI agents reliable.',
+        '',
+        'Instructions in markdown are suggestions. The agent can ignore them after context compaction, hallucinate past them, or just decide they don\'t apply.',
+        '',
+        'You need enforcement — gates that physically block bad actions before execution.',
+        '',
+        'Memory helps agents remember. Gates make them comply.',
+      ].join('\n');
+
+    case 'community':
+      return [
+        `This week's most common agent mistake caught by ThumbGate users:`,
+        '',
+        `Agents trying to commit .env files to public repos.`,
+        '',
+        `It's such a common pattern that we made it a default gate. Works across Claude Code, Cursor, and Codex.`,
+        '',
+        `What's the most dangerous thing your AI agent has tried to do? Genuinely curious.`,
+      ].join('\n');
+
+    case 'tip':
+      return [
+        'Quick tip for Claude Code users:',
+        '',
+        'Add a PreToolUse hook that checks for `git push --force` before every Bash call.',
+        '',
+        'One line of prevention saves hours of rollback.',
+        '',
+        `ThumbGate automates this — generates hooks from your feedback: ${REPO}`,
+      ].join('\n');
+
+    case 'stats':
+      return post; // Use the generated weekly stats
+
+    default:
+      return post;
+  }
+}
+
+async function main() {
+  const dryRun = process.argv.includes('--dry-run');
+  const angle = getTodayAngle();
+  const content = generatePost(angle);
+
+  console.log(`[daily-post] Day: ${new Date().toUTCString()}`);
+  console.log(`[daily-post] Angle: ${angle}`);
+  console.log(`[daily-post] Content:\n${content}\n`);
+
+  if (dryRun) {
+    console.log('[daily-post] Dry run — not posting.');
+    return;
+  }
+
+  // Fetch connected accounts, filter to text-friendly platforms (no Reddit, no Instagram)
+  const accounts = await getConnectedAccounts();
+  const textAccounts = accounts
+    .filter(a => TEXT_PLATFORMS.has(a.platform))
+    .map(a => ({ platform: a.platform, accountId: a._id || a.accountId }));
+
+  if (textAccounts.length === 0) {
+    console.error('[daily-post] No text-friendly accounts connected.');
+    process.exit(1);
+  }
+
+  console.log(`[daily-post] Publishing to ${textAccounts.length} platform(s): ${textAccounts.map(a => a.platform).join(', ')}`);
+
+  const result = await publishPost(content, textAccounts);
+  console.log('[daily-post] Result:', JSON.stringify(result, null, 2));
+
+  if (result.platformResults) {
+    for (const pr of result.platformResults) {
+      if (pr.status === 'published') {
+        console.log(`[daily-post] ${pr.platform}: published`);
+      } else {
+        console.error(`[daily-post] ${pr.platform}: ${pr.status} — ${pr.error || 'unknown'}`);
+      }
+    }
+  }
+}
+
+main().catch(err => {
+  console.error('[daily-post] Fatal:', err.message);
+  process.exit(1);
+});

package/scripts/social-quality-gate.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 'use strict';
+
 const BOT_SLOP_PATTERNS = [
   { id: 'emoji_spam', pattern: /(?:🚀|💡|🔥|⚡|🎯|💪|🙌|👀){3,}/g, reason: 'Excessive emoji spam' },
   { id: 'generic_opener', pattern: /^(?:Just|Excited to|Thrilled to|Happy to|Proud to) (?:\w+ )*?(?:launch|ship|release|publish|built|creat|announc)/i, reason: 'Generic shipped opener' },
@@ -11,8 +12,123 @@ const BOT_SLOP_PATTERNS = [
   { id: 'self_congratulation', pattern: /(?:We're proud to|I'm honored to|Humbled to|Grateful to announce)/i, reason: 'Self-congratulatory opener' },
   { id: 'empty_hype', pattern: /(?:game.?changer|revolutionary|disruptive|next.?gen|cutting.?edge|world.?class|best.?in.?class)/i, reason: 'Empty hype words' },
 ];
+
+const REPLY_TOPIC_PATTERNS = {
+  skills: /\bskill|template|process|workflow|review|sprint|implement|phase/i,
+  context: /\bcontext doc|context docs|conflicting|inconsisten|claude\.md|cursorrules|instruction/i,
+  memory: /\bmemory|remember|amnesia|across sessions|next session|compaction|persist/i,
+  setup: /\binstall|setup|config|init|repo|github|link|tool|open source|built/i,
+  gates: /\bgate|hook|block|prevent|pretooluse|mcp/i,
+};
+
+const UNSOLICITED_PROMO_PATTERNS = [
+  { id: 'unsolicited_link', pattern: /https?:\/\//i, reason: 'Unsolicited link in reply' },
+  { id: 'unsolicited_install', pattern: /npx thumbgate init/i, reason: 'Unsolicited install CTA in reply' },
+  { id: 'unsolicited_stack_dump', pattern: /\b(?:sqlite\+fts5|thompson sampling|pretooluse|mcp server)\b/i, reason: 'Unsolicited architecture dump in reply' },
+];
+
 const MIN_POST_LENGTH = 30;
 const MAX_POST_LENGTH = 2000;
-function scanForSlop(postText) { const text = String(postText || ''); const findings = []; if (text.length < MIN_POST_LENGTH) findings.push({ id: 'too_short', reason: 'Too short' }); if (text.length > MAX_POST_LENGTH) findings.push({ id: 'too_long', reason: 'Too long' }); for (const p of BOT_SLOP_PATTERNS) { p.pattern.lastIndex = 0; if (p.pattern.test(text)) findings.push({ id: p.id, reason: p.reason }); } const words = text.split(/\s+/).filter(w => w.length > 3); const capsWords = words.filter(w => w === w.toUpperCase() && /[A-Z]/.test(w)); if (words.length > 5 && capsWords.length / words.length > 0.3) findings.push({ id: 'caps_shouting', reason: 'Too many ALL CAPS' }); return { allowed: findings.length === 0, findings, findingCount: findings.length, postLength: text.length }; }
-function gatePost(postText) { const scan = scanForSlop(postText); if (!scan.allowed) { console.error('[social-quality-gate] BLOCKED:'); for (const f of scan.findings) console.error('  -', f.id, f.reason); } return scan; }
-module.exports = { scanForSlop, gatePost, BOT_SLOP_PATTERNS, MIN_POST_LENGTH, MAX_POST_LENGTH };
+
+function scanForSlop(postText) {
+  const text = String(postText || '');
+  const findings = [];
+
+  if (text.length < MIN_POST_LENGTH) {
+    findings.push({ id: 'too_short', reason: 'Too short' });
+  }
+
+  if (text.length > MAX_POST_LENGTH) {
+    findings.push({ id: 'too_long', reason: 'Too long' });
+  }
+
+  for (const rule of BOT_SLOP_PATTERNS) {
+    rule.pattern.lastIndex = 0;
+    if (rule.pattern.test(text)) {
+      findings.push({ id: rule.id, reason: rule.reason });
+    }
+  }
+
+  const words = text.split(/\s+/).filter((word) => word.length > 3);
+  const capsWords = words.filter((word) => word === word.toUpperCase() && /[A-Z]/.test(word));
+  if (words.length > 5 && capsWords.length / words.length > 0.3) {
+    findings.push({ id: 'caps_shouting', reason: 'Too many ALL CAPS' });
+  }
+
+  return {
+    allowed: findings.length === 0,
+    findings,
+    findingCount: findings.length,
+    postLength: text.length,
+  };
+}
+
+function detectReplyTopics(text) {
+  const content = String(text || '');
+  return Object.entries(REPLY_TOPIC_PATTERNS)
+    .filter(([, pattern]) => pattern.test(content))
+    .map(([topic]) => topic);
+}
+
+function commentExplicitlyRequestsProduct(commentText) {
+  return /\b(?:what tool|what is it|which tool|repo|github|link|where can i find|can you share|how do i install|setup details|what did you build)\b/i.test(
+    String(commentText || '')
+  );
+}
+
+function gateContextualReply(commentText, replyText, options = {}) {
+  const scan = scanForSlop(replyText);
+  const findings = [...scan.findings];
+  const comment = String(commentText || '');
+  const reply = String(replyText || '');
+  const platform = String(options.platform || '').toLowerCase();
+  const commentTopics = detectReplyTopics(comment);
+  const replyTopics = detectReplyTopics(reply);
+
+  if (commentTopics.length > 0 && !commentTopics.some((topic) => replyTopics.includes(topic))) {
+    findings.push({
+      id: 'not_contextual',
+      reason: 'Reply does not address the commenter’s actual point',
+    });
+  }
+
+  if (platform === 'reddit' && !commentExplicitlyRequestsProduct(comment)) {
+    for (const rule of UNSOLICITED_PROMO_PATTERNS) {
+      rule.pattern.lastIndex = 0;
+      if (rule.pattern.test(reply)) {
+        findings.push({ id: rule.id, reason: rule.reason });
+      }
+    }
+  }
+
+  return {
+    allowed: findings.length === 0,
+    findings,
+    findingCount: findings.length,
+    replyLength: reply.length,
+    commentTopics,
+    replyTopics,
+  };
+}
+
+function gatePost(postText) {
+  const scan = scanForSlop(postText);
+  if (!scan.allowed) {
+    console.error('[social-quality-gate] BLOCKED:');
+    for (const finding of scan.findings) {
+      console.error('  -', finding.id, finding.reason);
+    }
+  }
+  return scan;
+}
+
+module.exports = {
+  BOT_SLOP_PATTERNS,
+  MAX_POST_LENGTH,
+  MIN_POST_LENGTH,
+  commentExplicitlyRequestsProduct,
+  detectReplyTopics,
+  gateContextualReply,
+  gatePost,
+  scanForSlop,
+};

package/scripts/social-reply-monitor.js

@@ -16,12 +16,16 @@
  * State file: .thumbgate/reply-monitor-state.json — tracks which replies we've already responded to.
  */
 
-require('dotenv').config();
 const fs = require('fs');
 const path = require('path');
+const { loadLocalEnv } = require('./social-analytics/load-env');
+const { gateContextualReply, commentExplicitlyRequestsProduct } = require('./social-quality-gate');
 
 const STATE_FILE = path.resolve(__dirname, '..', '.thumbgate', 'reply-monitor-state.json');
 const REDDIT_API_BASE = 'https://oauth.reddit.com';
+const DEFAULT_X_HANDLE = 'IgorGanapolsky';
+
+loadLocalEnv();
 
 // ---------------------------------------------------------------------------
 // State management
@@ -58,6 +62,85 @@ function saveDraft(draft) {
   fs.appendFileSync(DRAFT_FILE, JSON.stringify(draft) + '\n');
 }
 
+function normalizeArray(value) {
+  if (value && Array.isArray(value.data)) {
+    return value.data;
+  }
+  return Array.isArray(value) ? value : [];
+}
+
+function isRevenueRelevantXTweet(tweet = {}) {
+  const text = String(tweet.text || '').toLowerCase();
+  if (!text) return false;
+  return /thumbgate|thumbgate-production|checkout\/pro|workflow-sprint|pre-action gates|vibe coding/.test(text);
+}
+
+function buildOwnedConversationQuery(tweetId, username = DEFAULT_X_HANDLE) {
+  const normalizedId = String(tweetId || '').trim();
+  const normalizedUsername = String(username || DEFAULT_X_HANDLE).trim();
+  if (!normalizedId) {
+    return '';
+  }
+  return `conversation_id:${normalizedId} -from:${normalizedUsername}`;
+}
+
+async function collectXSearchCandidates(options = {}) {
+  const searchTweets = options.searchTweets;
+  if (typeof searchTweets !== 'function') {
+    return { tweets: [], searchMode: 'unavailable', queryLog: [] };
+  }
+
+  const username = options.username || process.env.X_USERNAME || DEFAULT_X_HANDLE;
+  const ownUserId = options.ownUserId || process.env.X_USER_ID || '1733256637199073280';
+  const queryLog = [];
+  const aggregate = [];
+  const seenTweetIds = new Set();
+  let ownedCandidates = [];
+
+  if (typeof options.fetchOwnedTweets === 'function') {
+    try {
+      const recentTweets = await options.fetchOwnedTweets();
+      ownedCandidates = normalizeArray(recentTweets)
+        .filter((tweet) => String(tweet.author_id || ownUserId) === ownUserId)
+        .filter(isRevenueRelevantXTweet)
+        .slice(0, 6);
+    } catch (err) {
+      console.warn(`[reply-monitor] Could not fetch own X tweets: ${err.message}`);
+    }
+  }
+
+  for (const tweet of ownedCandidates) {
+    const query = buildOwnedConversationQuery(tweet.id, username);
+    if (!query) continue;
+    queryLog.push(query);
+    const replies = normalizeArray(await searchTweets(query, { maxResults: 10 }));
+    for (const reply of replies) {
+      if (!reply || seenTweetIds.has(reply.id)) continue;
+      seenTweetIds.add(reply.id);
+      aggregate.push(reply);
+    }
+  }
+
+  if (aggregate.length > 0) {
+    return {
+      tweets: aggregate,
+      ownTweets: ownedCandidates.map((tweet) => ({ id: tweet.id, text: tweet.text || '' })),
+      queryLog,
+      searchMode: 'owned_conversations',
+    };
+  }
+
+  const fallbackQuery = 'thumbgate OR ThumbGate OR "pre-action gates"';
+  queryLog.push(fallbackQuery);
+  const fallbackTweets = normalizeArray(await searchTweets(fallbackQuery, { maxResults: 10 }));
+  return {
+    tweets: fallbackTweets,
+    ownTweets: ownedCandidates.map((tweet) => ({ id: tweet.id, text: tweet.text || '' })),
+    queryLog,
+    searchMode: 'keyword_fallback',
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Bot/hostile detection — skip comments that are calling us out
 // ---------------------------------------------------------------------------
@@ -97,7 +180,8 @@ async function generateReply(comment, context) {
 
   // NEVER reply with generic fluff — build reply from what they ACTUALLY said
   const isQuestion = context.isQuestion || /\?/.test(comment);
-  const REPO = 'https://github.com/IgorGanapolsky/ThumbGate';
+  const isReddit = context.platform === 'reddit';
+  const wantsProductDetails = commentExplicitlyRequestsProduct(comment);
 
   // Extract the specific topic they're asking about
   const mentionsSetup = /install|setup|config|init|npx|how.+start/i.test(lc);
@@ -108,30 +192,59 @@ async function generateReply(comment, context) {
   const mentionsScaling = /scale|team|multi.?repo|collaborate|share/i.test(lc);
   const mentionsSkeptical = /why not|already exist|what.+different|vs |compared to/i.test(lc);
   const mentionsThanks = /thanks|thank you|cool|nice|interesting|awesome/i.test(lc);
+  const mentionsSkillsProcess = /skill|template|process|workflow|review|sprint|implement|phase/i.test(lc);
+  const mentionsConflictingDocs = /context doc|context docs|conflicting|inconsisten|claude\.md|cursorrules|instruction/i.test(lc);
 
   // Build response that addresses THEIR specific point
-  if (mentionsSetup && isQuestion) {
+  if (mentionsSkillsProcess || mentionsConflictingDocs) {
+    const reply = [
+      'That matches what I have seen too.',
+      'Smaller review/implement phases hold up much better than one giant instruction blob,',
+      'and conflicting context docs are where things usually start drifting.'
+    ].join(' ');
+    const gate = gateContextualReply(comment, reply, context);
+    return gate.allowed ? reply : null;
+  }
+  if (mentionsSetup && isQuestion && !isReddit) {
     return `\`npx thumbgate init\` auto-detects your agent and wires the hooks. Takes about 30 seconds. What agent are you using?`;
   }
   if (mentionsSkeptical) {
-    return `Fair question. The difference from rules files or memory tools: this physically blocks the action before execution, not after. The agent can't ignore a gate the way it can ignore a system prompt. Whether that tradeoff is worth it depends on how often your agent repeats mistakes.`;
+    const reply = 'Fair question. The difference from rules files or memory tools is enforcement: the bad action gets stopped before execution instead of being remembered and then ignored. Whether that tradeoff is worth it depends on how often your agent repeats the same mistake.';
+    const gate = gateContextualReply(comment, reply, context);
+    return gate.allowed ? reply : null;
   }
   if (mentionsHow && mentionsGates) {
-    return `PreToolUse hooks intercept the tool call before it runs. Each call is checked against prevention rules promoted from past failures. If it matches, the action is blocked — the agent has to try a different approach. The rules adapt over time via Thompson Sampling so false positives decrease.`;
+    const reply = isReddit
+      ? 'The short version is: the tool call gets checked before it runs. If it matches a previously rejected pattern, it is blocked and the agent has to try a different path.'
+      : 'PreToolUse hooks intercept the tool call before it runs. Each call is checked against prevention rules promoted from past failures. If it matches, the action is blocked and the agent has to try a different approach. The rules adapt over time so false positives decrease.';
+    const gate = gateContextualReply(comment, reply, context);
+    return gate.allowed ? reply : null;
   }
   if (mentionsScaling) {
-    return `For teams, the Pro tier syncs prevention rules across machines so everyone benefits from lessons learned on any repo. But the free local version covers solo dev workflows completely.`;
+    if (isReddit && !wantsProductDetails) {
+      return null;
+    }
+    const reply = 'For teams, the useful part is shared lessons instead of each developer relearning the same failure pattern alone. Solo workflows usually benefit first from the local version.';
+    const gate = gateContextualReply(comment, reply, context);
+    return gate.allowed ? reply : null;
   }
   if (mentionsMemory && isQuestion) {
-    return `The key difference from memory tools: memory helps agents remember, but they can still ignore what they remember. Gates enforce — if there's a rule against force-pushing, the agent physically can't do it. It's enforcement, not suggestion.`;
+    const reply = 'The useful distinction is memory versus enforcement. Memory helps the agent remember, but it can still ignore that memory. Enforcement is what stops the already-rejected move from happening again.';
+    const gate = gateContextualReply(comment, reply, context);
+    return gate.allowed ? reply : null;
   }
-  if (mentionsCursor && isQuestion) {
-    return `Works with Cursor via MCP. The hooks are agent-agnostic — same prevention rules apply whether you're using Cursor, Claude Code, or Codex. What specific failure patterns are you hitting?`;
+  if (mentionsCursor && isQuestion && !isReddit) {
+    return 'Works with Cursor via MCP. The same prevention rules can apply across Cursor, Claude Code, and Codex. What specific failure patterns are you hitting?';
   }
   if (mentionsThanks && !isQuestion) {
     // Don't reply to simple "thanks" — it looks desperate
     return null;
   }
+  if (isReddit && wantsProductDetails) {
+    const reply = 'Happy to share the repo or setup details if that would help. The main thing that worked for me was keeping accepted and rejected patterns outside the session so the next run starts with the same constraints.';
+    const gate = gateContextualReply(comment, reply, context);
+    return gate.allowed ? reply : null;
+  }
   if (isQuestion) {
     // They asked something specific we didn't match — better to draft for human review
     return null;
@@ -260,29 +373,41 @@ async function checkXReplies(state, dryRun) {
 
   // Use the post-to-x module for OAuth signing
   let xModule;
+  let xPoller;
   try {
     xModule = require('./post-to-x.js');
+    xPoller = require('./social-analytics/pollers/x.js');
   } catch {
-    console.warn('[reply-monitor] Could not load post-to-x.js, skipping X');
+    console.warn('[reply-monitor] Could not load X modules, skipping X');
     return [];
   }
 
-  // Search for recent mentions
-  let mentions;
+  let searchResult;
   try {
-    mentions = await xModule.searchTweets('thumbgate OR ThumbGate OR "pre-action gates"');
+    searchResult = await collectXSearchCandidates({
+      searchTweets: xModule.searchTweets,
+      fetchOwnedTweets: process.env.X_BEARER_TOKEN && process.env.X_USER_ID
+        ? async () => {
+          const response = await xPoller.fetchUserTweets(process.env.X_BEARER_TOKEN, process.env.X_USER_ID);
+          return response && response.data;
+        }
+        : null,
+      ownUserId: process.env.X_USER_ID || '1733256637199073280',
+      username: process.env.X_USERNAME || DEFAULT_X_HANDLE,
+    });
   } catch (err) {
     console.warn(`[reply-monitor] X search failed: ${err.message}`);
     return [];
   }
 
-  // searchTweets returns the array directly, not {data: [...]}
-  const mentionsList = Array.isArray(mentions) ? mentions : mentions?.data;
+  const mentionsList = normalizeArray(searchResult && searchResult.tweets);
   if (!mentionsList || mentionsList.length === 0) {
     console.log('[reply-monitor] No X mentions found');
     return [];
   }
 
+  console.log(`[reply-monitor] X candidate search mode: ${searchResult.searchMode}`);
+
   const results = [];
   const repliesSentThisRun = new Set(); // Track reply text to prevent duplicates
 
@@ -400,7 +525,14 @@ async function monitor({ platforms, dryRun } = {}) {
   return allResults;
 }
 
-module.exports = { monitor, generateReply };
+module.exports = {
+  buildOwnedConversationQuery,
+  checkXReplies,
+  collectXSearchCandidates,
+  generateReply,
+  isRevenueRelevantXTweet,
+  monitor,
+};
 
 // ---------------------------------------------------------------------------
 // CLI
@@ -418,22 +550,6 @@ if (require.main === module) {
   const platformArg = getArg('--platform');
   const platforms = platformArg ? [platformArg] : null;
 
-  // Load .env
-  const envPath = path.resolve(__dirname, '..', '.env');
-  if (fs.existsSync(envPath)) {
-    const envContent = fs.readFileSync(envPath, 'utf8');
-    for (const line of envContent.split('\n')) {
-      const trimmed = line.trim();
-      if (!trimmed || trimmed.startsWith('#')) continue;
-      const eqIdx = trimmed.indexOf('=');
-      if (eqIdx > 0) {
-        const key = trimmed.slice(0, eqIdx);
-        const value = trimmed.slice(eqIdx + 1);
-        if (!process.env[key]) process.env[key] = value;
-      }
-    }
-  }
-
   monitor({ platforms, dryRun })
     .then((results) => {
       console.log('\n[reply-monitor] Summary:', JSON.stringify(results, null, 2));

package/scripts/statusline-cache-path.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+'use strict';
+
+const path = require('path');
+const { resolveFeedbackDir } = require('./feedback-paths');
+
+function unique(values = []) {
+  return [...new Set(values.filter(Boolean).map((value) => path.resolve(value)))];
+}
+
+function getStatuslineCacheCandidates(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const home = options.home || process.env.HOME || process.env.USERPROFILE || '';
+  const feedbackDir = resolveFeedbackDir({ cwd, env: options.env || process.env });
+
+  return unique([
+    path.join(feedbackDir, 'statusline_cache.json'),
+    path.join(cwd, '.thumbgate', 'statusline_cache.json'),
+    home ? path.join(home, '.thumbgate', 'statusline_cache.json') : null,
+  ]);
+}
+
+if (require.main === module) {
+  process.stdout.write(JSON.stringify({ candidates: getStatuslineCacheCandidates() }));
+}
+
+module.exports = { getStatuslineCacheCandidates };

package/scripts/statusline-meta.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+'use strict';
+
+const path = require('path');
+const { isProLicensed } = require('./license');
+
+function getStatuslineMeta(options = {}) {
+  const pkg = require(path.join(__dirname, '..', 'package.json'));
+  const env = options.env || process.env;
+  const homeDir = options.homeDir || env.HOME || env.USERPROFILE || '.';
+
+  return {
+    version: String(pkg.version || '').trim() || 'unknown',
+    tier: isProLicensed({ homeDir }) ? 'Pro' : 'Free',
+  };
+}
+
+if (require.main === module) {
+  process.stdout.write(JSON.stringify(getStatuslineMeta()));
+}
+
+module.exports = { getStatuslineMeta };