thumbgate 0.9.10 → 0.9.12

package/scripts/published-cli.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+function shellQuote(value) {
+  return JSON.stringify(String(value));
+}
+
+function runtimePrefixDir(prefixDir) {
+  return prefixDir || path.join(os.homedir(), '.thumbgate', 'runtime');
+}
+
+function publishedCliArgs(pkgVersion, commandArgs = [], options = {}) {
+  return [
+    'exec',
+    '--prefix',
+    runtimePrefixDir(options.prefixDir),
+    '--yes',
+    '--package',
+    `thumbgate@${pkgVersion}`,
+    '--',
+    'thumbgate',
+    ...commandArgs,
+  ];
+}
+
+function publishedCliShellCommand(pkgVersion, commandArgs = [], options = {}) {
+  const prefixDir = runtimePrefixDir(options.prefixDir);
+  return `mkdir -p ${shellQuote(prefixDir)} && exec npm ${publishedCliArgs(pkgVersion, commandArgs, { prefixDir }).map(shellQuote).join(' ')}`;
+}
+
+function runPublishedCli(pkgVersion, commandArgs = [], options = {}) {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'thumbgate-published-cli-'));
+  const prefixDir = path.join(tmpDir, 'runtime');
+  try {
+    fs.mkdirSync(prefixDir, { recursive: true });
+    return execFileSync('npm', publishedCliArgs(pkgVersion, commandArgs, { prefixDir }), {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: options.timeout || 8000,
+      cwd: tmpDir,
+    });
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+
+function runPublishedCliHelp(pkgVersion, options = {}) {
+  return runPublishedCli(pkgVersion, ['help'], options);
+}
+
+module.exports = {
+  publishedCliArgs,
+  publishedCliShellCommand,
+  runtimePrefixDir,
+  runPublishedCli,
+  runPublishedCliHelp,
+};

package/scripts/risk-scorer.js

@@ -3,9 +3,10 @@
 
 const fs = require('fs');
 const path = require('path');
+const { resolveFeedbackDir: resolveSharedFeedbackDir } = require('./feedback-paths');
 
 const PROJECT_ROOT = path.join(__dirname, '..');
-const DEFAULT_FEEDBACK_DIR = path.join(PROJECT_ROOT, '.claude', 'memory', 'feedback');
+const DEFAULT_FEEDBACK_DIR = resolveSharedFeedbackDir();
 const DEFAULT_MODEL_PATH = path.join(DEFAULT_FEEDBACK_DIR, 'risk-model.json');
 const DEFAULT_SEQUENCE_PATH = path.join(DEFAULT_FEEDBACK_DIR, 'feedback-sequences.jsonl');
 
@@ -29,7 +30,7 @@ const SAFETY_WORD_RE = /\b(budget|path|guardrail|safe|security|risk)\b/i;
 const SUCCESS_WORD_RE = /\b(pass|worked|fixed|success|verified)\b/i;
 
 function resolveFeedbackDir(feedbackDir) {
-  return feedbackDir || process.env.THUMBGATE_FEEDBACK_DIR || DEFAULT_FEEDBACK_DIR;
+  return resolveSharedFeedbackDir({ feedbackDir });
 }
 
 function readJSONL(filePath) {

package/scripts/rlhf_session_start.sh

@@ -0,0 +1,32 @@
+#!/usr/bin/env bash
+# Best-effort Claude SessionStart hook that bootstraps ThumbGate/Codex support
+# for repos under ~/workspace/git without surfacing noisy hook errors.
+
+set -u
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+HOOK_INPUT="$(cat 2>/dev/null || true)"
+TARGET_DIR="${CLAUDE_PROJECT_DIR:-}"
+
+if [ -z "${TARGET_DIR}" ] && [ -n "${HOOK_INPUT}" ]; then
+  TARGET_DIR="$(printf '%s' "${HOOK_INPUT}" | /usr/bin/python3 -c 'import json,sys; raw=sys.stdin.read().strip(); print(json.loads(raw).get("cwd","")) if raw else print("")' 2>/dev/null || true)"
+fi
+
+if [ -z "${TARGET_DIR}" ]; then
+  TARGET_DIR="${PWD:-}"
+fi
+
+if [ -z "${TARGET_DIR}" ]; then
+  exit 0
+fi
+
+REPO_ROOT="$(git -C "${TARGET_DIR}" rev-parse --show-toplevel 2>/dev/null || true)"
+WORKSPACE_ROOT="${HOME:-}/workspace/git"
+
+case "${REPO_ROOT}" in
+  "${WORKSPACE_ROOT}"/*) ;;
+  *) exit 0 ;;
+esac
+
+node "${SCRIPT_DIR}/ensure-repo-bootstrap.js" "${REPO_ROOT}" >/dev/null 2>&1 || true
+exit 0

package/scripts/skill-quality-tracker.js

@@ -15,15 +15,13 @@
 const fs = require('fs');
 const readline = require('readline');
 const path = require('path');
-
-const FEEDBACK_DIR = process.env.THUMBGATE_FEEDBACK_DIR
-  || path.join(__dirname, '..', '.claude', 'memory', 'feedback');
+const { resolveFeedbackDir } = require('./feedback-paths');
 
 const METRICS_PATH = process.env.METRICS_PATH
-  || path.join(FEEDBACK_DIR, 'tool-metrics.jsonl');
+  || path.join(resolveFeedbackDir(), 'tool-metrics.jsonl');
 
 const FEEDBACK_PATH = process.env.FEEDBACK_PATH
-  || path.join(FEEDBACK_DIR, 'feedback-log.jsonl');
+  || path.join(resolveFeedbackDir(), 'feedback-log.jsonl');
 
 // Correlation window: feedback within 60 seconds of a tool call is considered correlated
 const CORRELATION_WINDOW_MS = 60_000;

package/scripts/social-analytics/engagement-audit.js

@@ -0,0 +1,202 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+const DEFAULT_REPLY_STATE_PATH = path.join(REPO_ROOT, '.thumbgate', 'reply-monitor-state.json');
+const DEFAULT_DRAFTS_PATH = path.join(REPO_ROOT, '.thumbgate', 'reply-drafts.jsonl');
+const DEFAULT_LAUNCH_ASSETS_PATH = path.join(REPO_ROOT, '.thumbgate', 'social-launch-assets.json');
+const DEFAULT_TIMEZONE = 'America/New_York';
+
+const PLATFORM_CAPABILITIES = {
+  x: 'active_reply_monitor',
+  reddit: 'draft_only_reply_monitor',
+  linkedin: 'comment_intake_blocked_by_api_approval',
+  instagram: 'no_comment_intake_implemented',
+  tiktok: 'no_comment_intake_implemented',
+  youtube: 'no_comment_intake_implemented',
+  devto: 'no_comment_intake_implemented',
+};
+
+function parseArgs(argv = []) {
+  const options = {
+    date: '',
+    timezone: DEFAULT_TIMEZONE,
+    replyStatePath: DEFAULT_REPLY_STATE_PATH,
+    draftsPath: DEFAULT_DRAFTS_PATH,
+    launchAssetsPath: DEFAULT_LAUNCH_ASSETS_PATH,
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = String(argv[index] || '').trim();
+    if (token.startsWith('--date=')) {
+      options.date = token.slice('--date='.length).trim();
+      continue;
+    }
+    if (token === '--date' && argv[index + 1]) {
+      options.date = String(argv[index + 1]).trim();
+      index += 1;
+      continue;
+    }
+    if (token.startsWith('--timezone=')) {
+      options.timezone = token.slice('--timezone='.length).trim() || DEFAULT_TIMEZONE;
+    }
+  }
+
+  return options;
+}
+
+function readJson(filePath, fallback) {
+  try {
+    if (!fs.existsSync(filePath)) {
+      return fallback;
+    }
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return fallback;
+  }
+}
+
+function readJsonl(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return [];
+  }
+  return fs.readFileSync(filePath, 'utf8')
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean);
+}
+
+function formatDateInTimezone(date, timezone = DEFAULT_TIMEZONE) {
+  const formatter = new Intl.DateTimeFormat('en-CA', {
+    timeZone: timezone,
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+  });
+  return formatter.format(new Date(date));
+}
+
+function buildPlatformSummary() {
+  return {
+    checked: 0,
+    replied: 0,
+    drafted: 0,
+    skipped: 0,
+    skippedOwnTweet: 0,
+    skippedNoReplyGenerated: 0,
+    capability: '',
+    ownedLaunchAssets: 0,
+  };
+}
+
+function buildEngagementAudit(options = {}) {
+  const timezone = options.timezone || DEFAULT_TIMEZONE;
+  const targetDate = options.date || formatDateInTimezone(new Date(), timezone);
+  const replyState = readJson(options.replyStatePath || DEFAULT_REPLY_STATE_PATH, { repliedTo: {}, lastCheck: {} });
+  const drafts = readJsonl(options.draftsPath || DEFAULT_DRAFTS_PATH);
+  const launchAssets = readJson(options.launchAssetsPath || DEFAULT_LAUNCH_ASSETS_PATH, { launchPosts: {}, campaignPosts: {} });
+
+  const platforms = {
+    x: buildPlatformSummary(),
+    reddit: buildPlatformSummary(),
+    linkedin: buildPlatformSummary(),
+    instagram: buildPlatformSummary(),
+    tiktok: buildPlatformSummary(),
+    youtube: buildPlatformSummary(),
+    devto: buildPlatformSummary(),
+  };
+
+  for (const [platform, capability] of Object.entries(PLATFORM_CAPABILITIES)) {
+    platforms[platform].capability = capability;
+  }
+
+  for (const entry of Object.values(replyState.repliedTo || {})) {
+    const platform = String(entry.platform || '').trim().toLowerCase();
+    if (!platforms[platform]) continue;
+    if (formatDateInTimezone(entry.at, timezone) !== targetDate) continue;
+    platforms[platform].checked += 1;
+    if (entry.drafted) {
+      platforms[platform].drafted += 1;
+      continue;
+    }
+    if (entry.skipped) {
+      platforms[platform].skipped += 1;
+      if (entry.skipped === 'own_tweet') {
+        platforms[platform].skippedOwnTweet += 1;
+      }
+      if (entry.skipped === 'no_reply_generated') {
+        platforms[platform].skippedNoReplyGenerated += 1;
+      }
+      continue;
+    }
+    platforms[platform].replied += 1;
+  }
+
+  for (const draft of drafts) {
+    const platform = String(draft.platform || '').trim().toLowerCase();
+    if (!platforms[platform]) continue;
+    if (formatDateInTimezone(draft.draftedAt, timezone) !== targetDate) continue;
+    platforms[platform].drafted += 1;
+  }
+
+  for (const platform of Object.keys(launchAssets.launchPosts || {})) {
+    if (platforms[platform]) {
+      platforms[platform].ownedLaunchAssets += 1;
+    }
+  }
+  for (const byPlatform of Object.values(launchAssets.campaignPosts || {})) {
+    for (const platform of Object.keys(byPlatform || {})) {
+      if (platforms[platform]) {
+        platforms[platform].ownedLaunchAssets += 1;
+      }
+    }
+  }
+
+  const totals = Object.values(platforms).reduce((acc, platform) => {
+    acc.checked += platform.checked;
+    acc.replied += platform.replied;
+    acc.drafted += platform.drafted;
+    acc.skipped += platform.skipped;
+    return acc;
+  }, { checked: 0, replied: 0, drafted: 0, skipped: 0 });
+
+  return {
+    date: targetDate,
+    timezone,
+    totals,
+    platforms,
+    evidence: {
+      replyStatePath: options.replyStatePath || DEFAULT_REPLY_STATE_PATH,
+      draftsPath: options.draftsPath || DEFAULT_DRAFTS_PATH,
+      launchAssetsPath: options.launchAssetsPath || DEFAULT_LAUNCH_ASSETS_PATH,
+    },
+  };
+}
+
+if (require.main === module) {
+  const audit = buildEngagementAudit(parseArgs(process.argv.slice(2)));
+  process.stdout.write(`${JSON.stringify(audit, null, 2)}\n`);
+}
+
+module.exports = {
+  DEFAULT_DRAFTS_PATH,
+  DEFAULT_LAUNCH_ASSETS_PATH,
+  DEFAULT_REPLY_STATE_PATH,
+  DEFAULT_TIMEZONE,
+  PLATFORM_CAPABILITIES,
+  buildEngagementAudit,
+  formatDateInTimezone,
+  parseArgs,
+  readJsonl,
+};

package/scripts/social-analytics/instagram-thumbgate-post.js

@@ -12,8 +12,9 @@
 const path = require('path');
 const {
   publishPost,
-  publishToAllPlatforms,
+  schedulePost,
   getConnectedAccounts,
+  uploadLocalMedia,
 } = require('./publishers/zernio');
 
 const THUMBGATE_CAPTION = `Your AI coding agent has amnesia. It forgets everything between sessions.
@@ -24,9 +25,14 @@ One command: npx thumbgate init
 
 Works with Claude Code, Cursor, Codex, Gemini.
 
-#AIAgents #DeveloperTools #CodingAgents #MCP #OpenSource #ClaudeCode #ThumbGate`;
+#AIAgents #DeveloperTools #ClaudeCode #ThumbGate`;
+
+async function postThumbGateToInstagram(options = {}) {
+  const caption = String(options.caption || THUMBGATE_CAPTION).trim();
+  const imagePath = options.imagePath ? path.resolve(options.imagePath) : '';
+  const schedule = String(options.schedule || '').trim();
+  const timezone = String(options.timezone || 'America/New_York').trim() || 'America/New_York';
 
-async function postThumbGateToInstagram() {
   try {
     console.log('[instagram] Fetching Zernio connected accounts...');
     const accounts = await getConnectedAccounts();
@@ -46,10 +52,38 @@ async function postThumbGateToInstagram() {
       },
     ];
 
-    console.log('[instagram] Publishing ThumbGate caption to Instagram...');
-    const result = await publishPost(THUMBGATE_CAPTION, platforms);
+    if (!imagePath) {
+      throw new Error('Instagram posts require an imagePath because Zernio requires media content for Instagram posts.');
+    }
+
+    console.log(`[instagram] Uploading Instagram media from ${imagePath}...`);
+    const mediaItem = await uploadLocalMedia(imagePath);
 
-    console.log('✅ Post published successfully!');
+    const publishOptions = {
+      mediaItems: [mediaItem],
+      utm: options.utm,
+    };
+
+    let result;
+    if (schedule) {
+      console.log(`[instagram] Scheduling Instagram post for ${schedule} (${timezone})...`);
+      result = await schedulePost(caption, platforms, schedule, timezone, publishOptions);
+    } else {
+      console.log('[instagram] Publishing ThumbGate caption to Instagram...');
+      result = await publishPost(caption, platforms, publishOptions);
+    }
+    if (result && result.blocked) {
+      const reasons = Array.isArray(result.reasons)
+        ? result.reasons.map((reason) => reason.reason || reason.id || String(reason)).join(', ')
+        : 'quality gate blocked the caption';
+      throw new Error(`Instagram post blocked: ${reasons}`);
+    }
+
+    if (schedule) {
+      console.log('✅ Instagram post scheduled successfully!');
+    } else {
+      console.log('✅ Post published successfully!');
+    }
     console.log(`Post ID: ${result.id || result.data?.id || 'unknown'}`);
     return result;
   } catch (err) {
@@ -60,9 +94,13 @@ async function postThumbGateToInstagram() {
 
 // CLI execution
 if (require.main === module) {
+  const args = process.argv.slice(2);
+  const imageArg = args.find((arg) => arg.startsWith('--image-path='));
+  const imagePath = imageArg ? imageArg.slice('--image-path='.length) : '';
+
   (async () => {
     try {
-      await postThumbGateToInstagram();
+      await postThumbGateToInstagram({ imagePath });
       process.exit(0);
     } catch (err) {
       process.exit(1);

package/scripts/social-analytics/install-growth-automation.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+'use strict';
+
+const path = require('node:path');
+const scheduleManager = require('../schedule-manager');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+const GROWTH_REPORT_DIR = path.join(REPO_ROOT, '.thumbgate', 'reports', 'gtm-revenue-loop');
+
+function buildNodeEvalCommand(scriptPath, args = []) {
+  const absolutePath = path.resolve(scriptPath);
+  const serializedArgs = JSON.stringify(args);
+  return [
+    'const { spawnSync } = require(\'node:child_process\');',
+    `process.chdir(${JSON.stringify(REPO_ROOT)});`,
+    `const result = spawnSync(process.execPath, [${JSON.stringify(absolutePath)}, ...${serializedArgs}], {`,
+    '  cwd: process.cwd(),',
+    '  env: process.env,',
+    '  stdio: \'inherit\',',
+    '});',
+    'if (result.error) throw result.error;',
+    'process.exit(typeof result.status === \'number\' ? result.status : 0);',
+  ].join(' ');
+}
+
+function buildGrowthSchedules() {
+  return [
+    {
+      id: 'thumbgate-growth-schedule-campaign',
+      name: 'ThumbGate Growth Campaign Scheduler',
+      description: 'Schedules the next day of tracked Zernio launch posts.',
+      schedule: 'daily 21:15',
+      command: buildNodeEvalCommand(path.join(__dirname, 'schedule-thumbgate-campaign.js')),
+      workingDirectory: REPO_ROOT,
+    },
+    {
+      id: 'thumbgate-growth-poll-zernio',
+      name: 'ThumbGate Growth Poll Zernio',
+      description: 'Polls Zernio analytics into the local engagement store every hour.',
+      schedule: 'hourly',
+      command: buildNodeEvalCommand(path.join(__dirname, 'pollers', 'zernio.js')),
+      workingDirectory: REPO_ROOT,
+    },
+    {
+      id: 'thumbgate-growth-sync-launch-assets',
+      name: 'ThumbGate Growth Sync Launch Assets',
+      description: 'Syncs published and scheduled launch assets from Zernio into a durable local registry.',
+      schedule: 'hourly',
+      command: buildNodeEvalCommand(path.join(__dirname, 'sync-launch-assets.js')),
+      workingDirectory: REPO_ROOT,
+    },
+    {
+      id: 'thumbgate-growth-reply-monitor',
+      name: 'ThumbGate Growth Reply Monitor',
+      description: 'Checks social replies and posts supported follow-ups or drafts them for review.',
+      schedule: 'hourly',
+      command: buildNodeEvalCommand(path.join(REPO_ROOT, 'scripts', 'social-reply-monitor.js')),
+      workingDirectory: REPO_ROOT,
+    },
+    {
+      id: 'thumbgate-growth-money-watch',
+      name: 'ThumbGate Growth Money Watch',
+      description: 'Persists hourly commercial-change checks so the first paid event is captured immediately.',
+      schedule: 'hourly',
+      command: buildNodeEvalCommand(path.join(REPO_ROOT, 'scripts', 'money-watcher.js'), [
+        '--once',
+      ]),
+      workingDirectory: REPO_ROOT,
+    },
+    {
+      id: 'thumbgate-growth-revenue-loop',
+      name: 'ThumbGate Growth Revenue Loop',
+      description: 'Refreshes the local-first target queue and outreach artifact for the first paid customers.',
+      schedule: 'daily 08:20',
+      command: buildNodeEvalCommand(path.join(REPO_ROOT, 'scripts', 'autonomous-sales-agent.js'), [
+        `--report-dir=${GROWTH_REPORT_DIR}`,
+        '--max-targets=8',
+      ]),
+      workingDirectory: REPO_ROOT,
+    },
+    {
+      id: 'thumbgate-growth-social-digest',
+      name: 'ThumbGate Growth Social Digest',
+      description: 'Builds the daily social analytics digest after the day closes.',
+      schedule: 'daily 22:15',
+      command: buildNodeEvalCommand(path.join(__dirname, 'run-digest.js'), ['--days=7']),
+      workingDirectory: REPO_ROOT,
+    },
+  ];
+}
+
+function installGrowthAutomation(manager = scheduleManager) {
+  const schedules = buildGrowthSchedules();
+
+  const installed = schedules.map((schedule) => manager.createSchedule(schedule));
+  return {
+    installed,
+    schedules: manager.listSchedules().filter((schedule) => schedule.id.startsWith('thumbgate-growth-')),
+  };
+}
+
+if (require.main === module) {
+  const result = installGrowthAutomation();
+  process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+  if (result.installed.some((entry) => !entry.success)) {
+    process.exitCode = 1;
+  }
+}
+
+module.exports = {
+  buildNodeEvalCommand,
+  buildGrowthSchedules,
+  installGrowthAutomation,
+};

package/scripts/social-analytics/load-env.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const dotenv = require('dotenv');
+
+const DEFAULT_ENV_PATH = path.resolve(__dirname, '..', '..', '.env');
+
+function resolveEnvPath(envPath = DEFAULT_ENV_PATH) {
+  return path.isAbsolute(envPath) ? envPath : path.resolve(process.cwd(), envPath);
+}
+
+function loadLocalEnv(options = {}) {
+  const resolvedPath = resolveEnvPath(options.envPath);
+  if (!fs.existsSync(resolvedPath)) {
+    return {
+      exists: false,
+      loadedKeys: [],
+      path: resolvedPath,
+    };
+  }
+
+  const parsed = dotenv.parse(fs.readFileSync(resolvedPath, 'utf8'));
+  const loadedKeys = [];
+  const override = options.override === true;
+
+  for (const [key, value] of Object.entries(parsed)) {
+    if (!override && process.env[key] !== undefined) {
+      continue;
+    }
+    process.env[key] = value;
+    loadedKeys.push(key);
+  }
+
+  return {
+    exists: true,
+    loadedKeys,
+    path: resolvedPath,
+  };
+}
+
+module.exports = {
+  DEFAULT_ENV_PATH,
+  loadLocalEnv,
+  resolveEnvPath,
+};

package/scripts/social-analytics/poll-all.js

@@ -1,29 +1,17 @@
 'use strict';
 
-require('dotenv').config({ path: require('node:path').resolve(__dirname, '..', '..', '.env') });
 const path = require('node:path');
-const fs = require('node:fs');
-
-// Load .env if available
-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;
-    }
-  }
-}
+const { loadLocalEnv } = require('./load-env');
+
+loadLocalEnv({ envPath: path.resolve(__dirname, '..', '..', '.env') });
 
 const { initDb } = require('./store');
 
 const POLLERS = [
   { name: 'github', module: './pollers/github', envRequired: ['GITHUB_TOKEN'] },
+  // Direct Instagram Graph API poller. Requires INSTAGRAM_ACCESS_TOKEN + INSTAGRAM_USER_ID.
+  // When those are absent, Instagram engagement data is still captured via the Zernio poller
+  // below (getConnectedAccounts returns Instagram accounts when Zernio is connected to IG).
   { name: 'instagram', module: './pollers/instagram', envRequired: ['INSTAGRAM_ACCESS_TOKEN', 'INSTAGRAM_USER_ID'] },
   { name: 'tiktok', module: './pollers/tiktok', envRequired: ['TIKTOK_ACCESS_TOKEN'] },
   { name: 'linkedin', module: './pollers/linkedin', envRequired: ['LINKEDIN_ACCESS_TOKEN', 'LINKEDIN_PERSON_URN'] },
@@ -31,7 +19,10 @@ const POLLERS = [
   { name: 'reddit', module: './pollers/reddit', envRequired: ['REDDIT_CLIENT_ID', 'REDDIT_CLIENT_SECRET', 'REDDIT_USERNAME', 'REDDIT_PASSWORD'] },
   { name: 'threads', module: './pollers/threads', envRequired: ['THREADS_ACCESS_TOKEN', 'THREADS_USER_ID'] },
   { name: 'youtube', module: './pollers/youtube', envRequired: ['YOUTUBE_API_KEY', 'YOUTUBE_CHANNEL_ID'] },
-  { name: 'plausible', module: './pollers/plausible', envRequired: ['PLAUSIBLE_API_KEY', 'PLAUSIBLE_SITE_ID'] },
+  // PLAUSIBLE_SITE_ID defaults to thumbgate-production.up.railway.app if not set.
+  { name: 'plausible', module: './pollers/plausible', envRequired: ['PLAUSIBLE_API_KEY'] },
+  // Zernio covers all connected social accounts (including Instagram) via its unified API.
+  // Instagram posts published via Zernio will have their engagement metrics captured here.
   { name: 'zernio', module: './pollers/zernio', envRequired: ['ZERNIO_API_KEY'] },
 ];
 
@@ -52,10 +43,19 @@ async function pollAll(options = {}) {
 
     try {
       const mod = require(poller.module);
-      const fn = mod[`poll${poller.name.charAt(0).toUpperCase()}${poller.name.slice(1)}`]
-        || mod.pollGitHub || mod.pollInstagram || mod.pollTikTok
-        || mod.pollLinkedIn || mod.pollX || mod.pollReddit
-        || mod.pollThreads || mod.pollPlausible || mod.pollZernio;
+      // Resolve the poll function by trying the simple title-case name first, then
+      // known capitalization variants (pollGitHub, pollTikTok, pollLinkedIn, pollYouTube),
+      // and finally any exported function whose name starts with "poll" as a last resort.
+      const baseName = poller.name.charAt(0).toUpperCase() + poller.name.slice(1);
+      const KNOWN_VARIANTS = {
+        github:   'pollGitHub',
+        tiktok:   'pollTikTok',
+        linkedin: 'pollLinkedIn',
+        youtube:  'pollYouTube',
+      };
+      const fn = mod[`poll${baseName}`]
+        || (KNOWN_VARIANTS[poller.name] && mod[KNOWN_VARIANTS[poller.name]])
+        || Object.values(mod).find((v) => typeof v === 'function' && v.name && v.name.startsWith('poll'));
 
       if (!fn) {
         console.log(`⚠  ${poller.name}: no poll function found in module`);

package/scripts/social-analytics/pollers/plausible.js

@@ -23,10 +23,9 @@ const PLAUSIBLE_BASE = 'https://plausible.io/api/v1';
  */
 async function plausibleQuery(endpoint, params = {}) {
   const apiKey = process.env.PLAUSIBLE_API_KEY;
-  const siteId = process.env.PLAUSIBLE_SITE_ID;
+  const siteId = process.env.PLAUSIBLE_SITE_ID || 'thumbgate-production.up.railway.app';
 
   if (!apiKey) throw new Error('PLAUSIBLE_API_KEY is not set');
-  if (!siteId) throw new Error('PLAUSIBLE_SITE_ID is not set');
 
   const qs = new URLSearchParams({ site_id: siteId, ...params });
   const url = `${PLAUSIBLE_BASE}${endpoint}?${qs.toString()}`;
@@ -153,9 +152,8 @@ async function getFunnelMetrics(period = '7d') {
  * @returns {Promise<object>} Summary of stored results.
  */
 async function pollPlausible(db) {
-  const siteId = process.env.PLAUSIBLE_SITE_ID;
+  const siteId = process.env.PLAUSIBLE_SITE_ID || 'thumbgate-production.up.railway.app';
   if (!process.env.PLAUSIBLE_API_KEY) throw new Error('PLAUSIBLE_API_KEY is not set');
-  if (!siteId) throw new Error('PLAUSIBLE_SITE_ID is not set');
 
   const period = '7d';
   const fetchedAt = new Date().toISOString();