thumbgate 1.27.16 → 1.27.18

package/scripts/statusline-cache-path.js

@@ -1,12 +1,7 @@
 #!/usr/bin/env node
 'use strict';
 
-const path = require('node:path');
-const os = require('node:os');
-const {
-  getAggregateStatuslineCachePath,
-  shouldAggregateFeedback,
-} = require('./feedback-aggregate');
+const path = require('path');
 const {
   listFeedbackArtifactPaths,
   resolveFeedbackDir,
@@ -17,28 +12,18 @@ function unique(values = []) {
   return [...new Set(values.filter(Boolean).map((value) => path.resolve(value)))];
 }
 
-function hasIsolatedTempFeedbackDir(env = process.env) {
-  if (!env.THUMBGATE_FEEDBACK_DIR) return false;
-  try {
-    return path.resolve(env.THUMBGATE_FEEDBACK_DIR).startsWith(path.resolve(os.tmpdir()) + path.sep);
-  } catch {
-    return false;
-  }
-}
-
 function getStatuslineCacheCandidates(options = {}) {
   const env = options.env || process.env;
   const projectDir = resolveProjectDir({ cwd: options.cwd, env });
   const feedbackDir = resolveFeedbackDir({ projectDir, env });
 
   return unique([
-    shouldAggregateFeedback({ env }) && !hasIsolatedTempFeedbackDir(env) && getAggregateStatuslineCachePath({ env }),
     ...listFeedbackArtifactPaths('statusline_cache.json', { projectDir, env }),
     path.join(feedbackDir, 'statusline_cache.json'),
   ]);
 }
 
-if (process.argv[1] && path.resolve(process.argv[1]) === path.resolve(__filename)) {
+if (require.main === module) {
   process.stdout.write(JSON.stringify({ candidates: getStatuslineCacheCandidates() }));
 }
 

package/scripts/statusline-local-stats.js

@@ -2,10 +2,6 @@
 'use strict';
 
 const { analyzeFeedback } = require('./feedback-loop');
-const {
-  computeAggregateFeedbackStats,
-  shouldAggregateFeedback,
-} = require('./feedback-aggregate');
 const { normalizeStatsPayload } = require('./hook-thumbgate-cache-updater');
 const { syncClaudeHistoryFeedback } = require('./claude-feedback-sync');
 const { resolveProjectDir } = require('./feedback-paths');
@@ -13,13 +9,9 @@ const { resolveProjectDir } = require('./feedback-paths');
 try {
   const projectDir = resolveProjectDir({ cwd: process.cwd(), env: process.env });
   syncClaudeHistoryFeedback({ projectDir });
-  const scope = String(process.env.THUMBGATE_STATUSLINE_SCOPE || 'global').toLowerCase();
-  const stats = scope !== 'project' && shouldAggregateFeedback({ env: process.env })
-    ? computeAggregateFeedbackStats({ projectDir, env: process.env })
-    : analyzeFeedback();
+  const stats = analyzeFeedback();
   const payload = {
     ...normalizeStatsPayload(stats),
-    aggregate: stats.aggregate || { enabled: false },
     updated_at: String(Math.floor(Date.now() / 1000)),
   };
   process.stdout.write(JSON.stringify(payload));

package/scripts/statusline-meta.js

@@ -2,42 +2,16 @@
 'use strict';
 
 const path = require('path');
-const { isProLicensed, isValidKey } = require('./license');
+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 || '.';
-  const fs = require('fs');
-  
-  // Enterprise detection based on key prefix
-  let apiKey = env.THUMBGATE_OPERATOR_KEY || env.THUMBGATE_API_KEY || '';
-  if (apiKey && !isValidKey(apiKey)) {
-    apiKey = '';
-  }
-  
-  // Fallback to reading from disk if not in env
-  if (!apiKey) {
-    try {
-      const configPath = path.join(homeDir, '.config', 'thumbgate', 'operator.json');
-      if (fs.existsSync(configPath)) {
-        const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-        apiKey = config.operatorKey || config.apiKey || '';
-      }
-    } catch (_) { /* ignore disk read errors */ }
-  }
-
-  let activeTier = 'Free';
-  
-  if (apiKey.startsWith('tg_op_') || apiKey.startsWith('tg_creator_')) {
-    activeTier = 'Enterprise';
-  } else if (isProLicensed({ homeDir }) || apiKey.startsWith('tg_pro_')) {
-    activeTier = 'Pro';
-  }
 
   return {
     version: String(pkg.version || '').trim() || 'unknown',
-    tier: activeTier,
+    tier: isProLicensed({ homeDir }) ? 'Pro' : 'Free',
   };
 }
 

package/scripts/statusline.sh

@@ -7,7 +7,6 @@
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)"
 case "$SCRIPT_DIR" in *[!a-zA-Z0-9/_.-]*) echo "ThumbGate: invalid script path"; exit 1;; esac
 LOCAL_API_ORIGIN="${THUMBGATE_LOCAL_API_ORIGIN:-http://localhost:3456}"
-STATUSLINE_VERBOSE="${THUMBGATE_STATUSLINE_VERBOSE:-0}"
 
 # ── Parse Claude Code session JSON from stdin ─────────────────────
 eval "$(cat | jq -r '
@@ -45,19 +44,7 @@ if [ -z "$THUMBGATE_CACHE" ]; then
 fi
 
 UP="0"; DOWN="0"; LESSONS="0"; TREND="?"; CACHE_TS="0"
-# Display reads aggregate across every per-folder cache so the statusline
-# reflects true totals, not whichever folder happens to be cwd. Writes still
-# target $THUMBGATE_CACHE (per-folder), so attribution is preserved.
-_RESOLVED_CACHE_JSON=$(node "${SCRIPT_DIR}/statusline-cache-read.js" 2>/dev/null)
-if [[ -n "$_RESOLVED_CACHE_JSON" ]]; then
-  eval "$(echo "$_RESOLVED_CACHE_JSON" | jq -r '
-    @sh "UP=\(.thumbs_up // "0")",
-    @sh "DOWN=\(.thumbs_down // "0")",
-    @sh "LESSONS=\(.lessons // "0")",
-    @sh "TREND=\(.trend // "?")",
-    @sh "CACHE_TS=\(.updated_at // "0")"
-  ' 2>/dev/null)"
-elif [[ -f "$THUMBGATE_CACHE" ]]; then
+if [ -f "$THUMBGATE_CACHE" ]; then
   eval "$(jq -r '
     @sh "UP=\(.thumbs_up // "0")",
     @sh "DOWN=\(.thumbs_down // "0")",
@@ -212,10 +199,8 @@ LINE="${LINE:+${LINE} · }ThumbGate v${TG_VERSION} · ${TG_TIER}"
 if [[ "$UP" = "0" && "$DOWN" = "0" ]]; then
   LINE="${D}${LINE}${RST} · no feedback yet"
   [[ -n "$PR_LABEL" ]] && LINE="${LINE} · ${D}${PR_LABEL}${RST}"
-  
-  LINE="${LINE} · ${C}${DASHBOARD_LINK}${RST}"
+  LINE="${LINE} · ${C}${DASHBOARD_LINK}${RST} · ${M}${LESSONS_LINK}${RST}"
   [[ -n "$LATEST_LESSON_LINK" ]] && LINE="${LINE} · ${D}${LATEST_LESSON_LINK}${RST}"
-  
   printf '%b\n' "$LINE"
 else
   LINE="${LINE} · ${G}${BD}${UP}${RST}${UP_LINK} ${R}${BD}${DOWN}${RST}${DOWN_LINK} ${ARROW}"
@@ -225,9 +210,8 @@ else
   [[ "${AT_RISK:-0}" -gt 0 ]] && LINE="${LINE} ${R}${AT_RISK}⚠${RST}"
   [[ "${ANOMALIES:-0}" -gt 0 ]] && LINE="${LINE} ${R}${ANOMALIES}☠${RST}"
   [[ -n "$PR_LABEL" ]] && LINE="${LINE} · ${D}${PR_LABEL}${RST}"
-  
-  LINE="${LINE} · ${C}${DASHBOARD_LINK}${RST}"
+  LINE="${LINE} · ${C}${DASHBOARD_LINK}${RST} · ${M}${LESSONS_LINK}${RST}"
   [[ -n "$LATEST_LESSON_LINK" ]] && LINE="${LINE} · ${D}${LATEST_LESSON_LINK}${RST}"
-  
+
   printf '%b\n' "$LINE"
 fi

package/scripts/telemetry-analytics.js

@@ -75,13 +75,6 @@ function normalizeInteger(value) {
   return Number.isFinite(parsed) ? Math.trunc(parsed) : null;
 }
 
-function normalizeRate(value) {
-  if (value === undefined || value === null || value === '') return null;
-  const parsed = Number(value);
-  if (!Number.isFinite(parsed)) return null;
-  return Math.max(0, Math.min(parsed, 1));
-}
-
 function safeRate(num, den) {
   if (!den) return 0;
   return Number((num / den).toFixed(4));
@@ -262,149 +255,6 @@ function inferTrafficChannel(raw = {}, referrerHost = null) {
   return 'referral';
 }
 
-function normalizeBoolean(value) {
-  if (value === true || value === false) return value;
-  const text = normalizeText(value, 32);
-  if (!text) return false;
-  return ['1', 'true', 'yes', 'y', 'bot'].includes(text.toLowerCase());
-}
-
-function includesAnyToken(values, tokens) {
-  const haystack = values
-    .map((value) => normalizeText(value, 512))
-    .filter(Boolean)
-    .join(' ')
-    .toLowerCase();
-  if (!haystack) return false;
-  return tokens.some((token) => haystack.includes(token));
-}
-
-function addAudienceReason(reasons, code) {
-  if (!reasons.includes(code)) reasons.push(code);
-}
-
-function classifyTelemetryAudience(entry = {}, raw = {}) {
-  const reasons = [];
-  const identityValues = [
-    raw.email,
-    raw.customerEmail,
-    raw.buyerEmail,
-    raw.userEmail,
-    entry.visitorId,
-    entry.sessionId,
-    entry.traceId,
-    entry.acquisitionId,
-    entry.installId,
-  ];
-  const attributionValues = [
-    entry.source,
-    entry.utmSource,
-    entry.utmMedium,
-    entry.utmCampaign,
-    entry.utmContent,
-    entry.creator,
-    entry.offerCode,
-    entry.campaignVariant,
-    entry.referrerHost,
-  ];
-  const eventValues = [
-    entry.eventType,
-    entry.event,
-    entry.page,
-    entry.landingPath,
-    entry.ctaId,
-    entry.reasonCode,
-    entry.reasonDetail,
-  ];
-  const userAgent = normalizeText(entry.userAgent || raw.userAgent, 512) || '';
-  const hostValues = [raw.host, raw.hostname, raw.origin, raw.url, raw.pageUrl, entry.referrerHost];
-
-  if (normalizeBoolean(entry.isBot || raw.isBot) || includesAnyToken([userAgent], [
-    'bot',
-    'crawler',
-    'spider',
-    'headless',
-    'playwright',
-    'puppeteer',
-    'curl/',
-    'wget/',
-    'lighthouse',
-  ])) {
-    addAudienceReason(reasons, 'bot_or_automation_user_agent');
-  }
-
-  if (includesAnyToken(identityValues, [
-    '@example.com',
-    'buyer@example.com',
-    'test@example.com',
-    'codex-verification',
-    'audit@thumbgate.ai',
-  ])) {
-    addAudienceReason(reasons, 'test_identity');
-  }
-
-  if (includesAnyToken([...attributionValues, ...eventValues], [
-    'codex',
-    'audit',
-    'verification',
-    'synthetic',
-    'smoke',
-    'probe',
-    'test',
-  ])) {
-    addAudienceReason(reasons, 'test_or_audit_attribution');
-  }
-
-  if (includesAnyToken(hostValues, [
-    'localhost',
-    '127.0.0.1',
-    '::1',
-    'thumbgate-production.up.railway.app',
-  ])) {
-    addAudienceReason(reasons, 'internal_host');
-  }
-
-  if (includesAnyToken([userAgent, ...identityValues], [
-    'codex',
-    'github-actions',
-    'node-fetch',
-    'thumbgate-analytics',
-    'thumbgate-verification',
-  ])) {
-    addAudienceReason(reasons, 'internal_operator_or_ci');
-  }
-
-  if (
-    (entry.clientType || entry.client) === 'unknown' &&
-    !pickFirstText(entry.visitorId, entry.sessionId, entry.acquisitionId, entry.installId, entry.traceId) &&
-    !userAgent &&
-    includesAnyToken([entry.source, entry.utmSource], ['direct', 'website'])
-  ) {
-    addAudienceReason(reasons, 'unknown_direct_no_identity');
-  }
-
-  const audience = reasons.includes('test_identity') || reasons.includes('test_or_audit_attribution')
-    ? 'test'
-    : (reasons.includes('bot_or_automation_user_agent')
-      ? 'bot'
-      : (
-        reasons.includes('internal_host') ||
-        reasons.includes('internal_operator_or_ci') ||
-        reasons.includes('unknown_direct_no_identity')
-          ? 'internal'
-          : 'external'
-      ));
-
-  return {
-    audience,
-    reasons,
-    isExternal: audience === 'external',
-    isInternal: audience === 'internal',
-    isTest: audience === 'test',
-    isBot: audience === 'bot',
-  };
-}
-
 function sanitizeTelemetryPayload(payload = {}, headers = {}) {
   const raw = payload && typeof payload === 'object' ? payload : {};
   const clientType = inferClientType(raw);
@@ -463,12 +313,6 @@ function sanitizeTelemetryPayload(payload = {}, headers = {}) {
     pipelineStatus: pickFirstText(raw.pipelineStatus, raw.workflowSprintStatus, raw.status),
     reasonCode,
     reasonDetail: pickFirstText(raw.reasonDetail, raw.reasonText, raw.otherReason, raw.notes),
-    integration: pickFirstText(raw.integration, raw.actionIntegration),
-    actionOperation: pickFirstText(raw.actionOperation, raw.operationId),
-    endpoint: pickFirstText(raw.endpoint, raw.apiPath),
-    decisionMode: pickFirstText(raw.decisionMode, raw.executionMode),
-    actionStatus: pickFirstText(raw.actionStatus, raw.status),
-    accepted: raw.accepted === undefined || raw.accepted === null ? null : Boolean(raw.accepted),
     pricingInterest: pickFirstText(raw.pricingInterest, raw.interestLevel),
     seoQuery: pickFirstText(raw.seoQuery, raw.query),
     seoSurface: pickFirstText(raw.seoSurface, raw.searchSurface, raw.surface),
@@ -487,22 +331,11 @@ function sanitizeTelemetryPayload(payload = {}, headers = {}) {
     httpStatus: normalizeInteger(raw.httpStatus),
     userAgent: pickFirstText(raw.userAgent, headers['user-agent']),
     isBot: pickFirstText(raw.isBot),
-    interstitialSampled: pickFirstText(raw.interstitialSampled),
-    interstitialSampleRate: normalizeRate(raw.interstitialSampleRate),
     attributionTagged: Boolean(
       pickFirstText(raw.utmSource, raw.utmMedium, raw.utmCampaign, raw.utmContent, raw.utmTerm)
     ),
   };
 
-  const audience = classifyTelemetryAudience(entry, raw);
-  entry.audience = audience.audience;
-  entry.trafficAudience = audience.audience;
-  entry.audienceReasons = audience.reasons;
-  entry.isExternal = audience.isExternal;
-  entry.isInternal = audience.isInternal;
-  entry.isTest = audience.isTest;
-  entry.isBotTraffic = audience.isBot;
-
   return entry;
 }
 
@@ -593,162 +426,9 @@ function summarizeRecentEvents(events) {
       community: entry.community || null,
       offerCode: entry.offerCode || null,
       campaignVariant: entry.campaignVariant || null,
-      audience: entry.audience || 'external',
-      audienceReasons: entry.audienceReasons || [],
     }));
 }
 
-function summarizeExternalTrafficQuality(events) {
-  const byAudience = {};
-  const byExclusionReason = {};
-  const externalVisitors = new Set();
-  const externalSessions = new Set();
-  const externalCheckoutStarters = new Set();
-  const pageViewsBySource = {};
-  const pageViewsByPath = {};
-  const pageViewsByTrafficChannel = {};
-  const checkoutStartsBySource = {};
-  const checkoutStartsByTrafficChannel = {};
-  const buyerLossReasons = {};
-  const visitorPaths = new Map();
-  let externalEvents = 0;
-  let excludedEvents = 0;
-  let externalWebEvents = 0;
-  let externalPageViews = 0;
-  let externalCtaClicks = 0;
-  let externalCheckoutStarts = 0;
-  let externalBuyerLossSignals = 0;
-
-  for (const entry of events) {
-    const audience = entry.audience || 'external';
-    incrementCounter(byAudience, audience);
-    if (audience !== 'external') {
-      excludedEvents += 1;
-      const reasons = Array.isArray(entry.audienceReasons) && entry.audienceReasons.length > 0
-        ? entry.audienceReasons
-        : [`${audience}_traffic`];
-      for (const reason of reasons) incrementCounter(byExclusionReason, reason);
-      continue;
-    }
-
-    externalEvents += 1;
-    if ((entry.clientType || entry.client) !== 'web') continue;
-
-    externalWebEvents += 1;
-    const visitorKey = pickFirstText(entry.visitorId, entry.installId, entry.sessionId);
-    if (visitorKey) externalVisitors.add(visitorKey);
-    if (entry.sessionId) externalSessions.add(entry.sessionId);
-
-    const eventType = entry.eventType || entry.event;
-    if (visitorKey) {
-      const pathRow = visitorPaths.get(visitorKey) || {
-        visitorKey,
-        firstSeenAt: entry.receivedAt || null,
-        lastSeenAt: entry.receivedAt || null,
-        source: entry.source || null,
-        trafficChannel: entry.trafficChannel || null,
-        events: [],
-        pages: [],
-        checkoutStarts: 0,
-      };
-      if (!pathRow.firstSeenAt || String(entry.receivedAt || '') < pathRow.firstSeenAt) {
-        pathRow.firstSeenAt = entry.receivedAt || null;
-      }
-      if (!pathRow.lastSeenAt || String(entry.receivedAt || '') > pathRow.lastSeenAt) {
-        pathRow.lastSeenAt = entry.receivedAt || null;
-      }
-      pathRow.events.push({
-        at: entry.receivedAt || null,
-        eventType,
-        page: entry.page || entry.landingPath || null,
-        ctaId: entry.ctaId || null,
-      });
-      if ((entry.page || entry.landingPath) && !pathRow.pages.includes(entry.page || entry.landingPath)) {
-        pathRow.pages.push(entry.page || entry.landingPath);
-      }
-      if (eventType === 'checkout_start' || eventType === 'checkout_bootstrap') {
-        pathRow.checkoutStarts += 1;
-      }
-      visitorPaths.set(visitorKey, pathRow);
-    }
-
-    if (eventType === 'landing_page_view') {
-      externalPageViews += 1;
-      incrementCounter(pageViewsBySource, entry.source);
-      incrementCounter(pageViewsByPath, entry.page);
-      incrementCounter(pageViewsByTrafficChannel, entry.trafficChannel);
-    }
-
-    if (isMarketingClickEvent(eventType)) {
-      externalCtaClicks += 1;
-    }
-
-    if (eventType === 'checkout_start' || eventType === 'checkout_bootstrap') {
-      externalCheckoutStarts += 1;
-      incrementCounter(checkoutStartsBySource, entry.source);
-      incrementCounter(checkoutStartsByTrafficChannel, entry.trafficChannel);
-      const starterKey = pickFirstText(
-        entry.acquisitionId,
-        entry.visitorId,
-        entry.sessionId,
-        entry.installId,
-        entry.traceId
-      );
-      if (starterKey) externalCheckoutStarters.add(starterKey);
-    }
-
-    if (eventType === 'checkout_cancelled' || eventType === 'checkout_abandoned' || eventType === 'reason_not_buying') {
-      externalBuyerLossSignals += 1;
-      incrementCounter(buyerLossReasons, entry.reasonCode);
-    }
-  }
-
-  const topPath = getTopCounterEntry(pageViewsByPath);
-  const topSource = getTopCounterEntry(pageViewsBySource);
-  const topTrafficChannel = getTopCounterEntry(pageViewsByTrafficChannel);
-  const topExclusionReason = getTopCounterEntry(byExclusionReason);
-
-  return {
-    rawEvents: events.length,
-    externalEvents,
-    excludedEvents,
-    internalEvents: byAudience.internal || 0,
-    testEvents: byAudience.test || 0,
-    botEvents: byAudience.bot || 0,
-    exclusionRate: safeRate(excludedEvents, events.length),
-    byAudience,
-    byExclusionReason,
-    topExclusionReason: topExclusionReason ? { key: topExclusionReason[0], count: topExclusionReason[1] } : null,
-    external: {
-      totalEvents: externalWebEvents,
-      uniqueVisitors: externalVisitors.size,
-      uniqueSessions: externalSessions.size,
-      uniqueCheckoutStarters: externalCheckoutStarters.size,
-      pageViews: externalPageViews,
-      ctaClicks: externalCtaClicks,
-      checkoutStarts: externalCheckoutStarts,
-      buyerLossSignals: externalBuyerLossSignals,
-      pageViewToCheckoutRate: safeRate(externalCheckoutStarts, externalPageViews),
-      visitorToCheckoutRate: safeRate(externalCheckoutStarts, externalVisitors.size),
-      bySource: pageViewsBySource,
-      byPath: pageViewsByPath,
-      byTrafficChannel: pageViewsByTrafficChannel,
-      checkoutStartsBySource,
-      checkoutStartsByTrafficChannel,
-      buyerLossReasons,
-      topSource: topSource ? { key: topSource[0], count: topSource[1] } : null,
-      topPath: topPath ? { key: topPath[0], count: topPath[1] } : null,
-      topTrafficChannel: topTrafficChannel ? { key: topTrafficChannel[0], count: topTrafficChannel[1] } : null,
-      visitorPaths: Array.from(visitorPaths.values())
-        .sort((a, b) => String(a.firstSeenAt || '').localeCompare(String(b.firstSeenAt || '')))
-        .slice(0, 50),
-    },
-    verdict: externalEvents > 0
-      ? (excludedEvents > externalEvents ? 'polluted_but_usable' : 'usable')
-      : (events.length > 0 ? 'polluted_no_external_signal' : 'missing'),
-  };
-}
-
 function getTelemetrySummary(feedbackDir, options = {}) {
   const analyticsWindow = resolveAnalyticsWindow(options);
   const telemetryLoadOptions = analyticsWindow.bounded
@@ -759,7 +439,6 @@ function getTelemetrySummary(feedbackDir, options = {}) {
     analyticsWindow,
     (entry) => entry && (entry.receivedAt || entry.timestamp)
   );
-  const trafficQuality = summarizeExternalTrafficQuality(events);
   const byClientType = {};
   const byEventType = {};
   const webVisitors = new Set();
@@ -847,12 +526,6 @@ function getTelemetrySummary(feedbackDir, options = {}) {
   let exitEngagementMsCount = 0;
   let exitScrollPercentTotal = 0;
   let exitScrollPercentCount = 0;
-  let chatgptActionCalls = 0;
-  let chatgptActionAccepted = 0;
-  const chatgptActionsByOperation = {};
-  const chatgptActionsByEndpoint = {};
-  const chatgptActionsByStatus = {};
-  const chatgptActionsByDecisionMode = {};
 
   for (const entry of events) {
     incrementCounter(byClientType, entry.clientType || entry.client || 'unknown');
@@ -1041,18 +714,6 @@ function getTelemetrySummary(feedbackDir, options = {}) {
       }
     }
 
-    if (
-      String(entry.eventType || entry.event || '').startsWith('chatgpt_action_') ||
-      entry.integration === 'chatgpt_gpt'
-    ) {
-      chatgptActionCalls += 1;
-      if (entry.accepted === true) chatgptActionAccepted += 1;
-      incrementCounter(chatgptActionsByOperation, entry.actionOperation);
-      incrementCounter(chatgptActionsByEndpoint, entry.endpoint);
-      incrementCounter(chatgptActionsByStatus, entry.actionStatus);
-      incrementCounter(chatgptActionsByDecisionMode, entry.decisionMode);
-    }
-
     if ((entry.clientType || entry.client) === 'cli') {
       if (entry.installId) cliInstalls.add(entry.installId);
       incrementCounter(cliByPlatform, entry.platform);
@@ -1103,14 +764,12 @@ function getTelemetrySummary(feedbackDir, options = {}) {
     window: serializeAnalyticsWindow(analyticsWindow),
     totalEvents: events.length,
     latestSeenAt,
-    trafficQuality,
     byClientType,
     byEventType,
     conversionFunnel: {
       landingViews: pageViews,
       installCopies,
       gptOpens,
-      gptActionCalls: chatgptActionCalls,
       checkoutStarts,
       checkoutInterstitialViews,
       checkoutInterstitialClicks,
@@ -1118,7 +777,6 @@ function getTelemetrySummary(feedbackDir, options = {}) {
       proConversions,
       landingToInstallCopyRate: safeRate(installCopies, pageViews),
       landingToGptOpenRate: safeRate(gptOpens, pageViews),
-      gptOpenToActionRate: safeRate(chatgptActionCalls, gptOpens),
       landingToCheckoutRate: safeRate(checkoutStarts, pageViews),
       checkoutInterstitialClickRate: safeRate(checkoutInterstitialClicks, checkoutInterstitialViews),
       checkoutInterstitialProConfirmRate: safeRate(checkoutInterstitialProConfirms, checkoutInterstitialViews),
@@ -1177,17 +835,6 @@ function getTelemetrySummary(feedbackDir, options = {}) {
       byPlatform: cliByPlatform,
       byVersion: cliByVersion,
     },
-    chatgpt: {
-      gptOpens,
-      actionCalls: chatgptActionCalls,
-      acceptedActionCalls: chatgptActionAccepted,
-      openToActionRate: safeRate(chatgptActionCalls, gptOpens),
-      acceptedActionRate: safeRate(chatgptActionAccepted, chatgptActionCalls),
-      byOperation: chatgptActionsByOperation,
-      byEndpoint: chatgptActionsByEndpoint,
-      byStatus: chatgptActionsByStatus,
-      byDecisionMode: chatgptActionsByDecisionMode,
-    },
     marketing: {
       pageViewsBySource,
       pageViewsByCampaign,
@@ -1279,12 +926,9 @@ function getTelemetryAnalytics(feedbackDir, options = {}) {
     window: summary.window,
     totalEvents: summary.totalEvents,
     latestSeenAt: summary.latestSeenAt,
-    trafficQuality: summary.trafficQuality,
-    qualified: summary.trafficQuality.external,
     byClientType: summary.byClientType,
     byEventType: summary.byEventType,
     conversionFunnel: summary.conversionFunnel,
-    chatgpt: summary.chatgpt,
     visitors: {
       totalEvents: summary.web.totalEvents,
       uniqueVisitors: summary.web.uniqueVisitors,
@@ -1460,7 +1104,6 @@ const appendTelemetryPing = appendTelemetryEvent;
 module.exports = {
   TELEMETRY_FILE_NAME,
   sanitizeTelemetryPayload,
-  classifyTelemetryAudience,
   appendTelemetryPing,
   appendTelemetryEvent,
   getTelemetrySourceDiagnostics,

package/scripts/thompson-sampling.js

@@ -302,44 +302,24 @@ function getCalibration(model) {
 // ---------------------------------------------------------------------------
 
 /**
- * Return the Beta posterior parameters after applying Thompson temperature
- * scaling. The posterior mean is preserved while precision changes:
- * lower temperatures sharpen the posterior, higher temperatures flatten it.
+ * Draw one sample from the Beta posterior for each category via the
+ * Marsaglia-Tsang (2000) gamma ratio method. No external library needed.
  *
- * @param {Object} params - Category posterior parameters
- * @param {number} temperature - Scaling factor (default 1.0)
- * @returns {{ alpha: number, beta: number }}
- */
-function getTemperatureScaledPosteriorParams(params, temperature = 1.0) {
-  const T = Math.max(0.01, Number(temperature) || 1.0);
-  const invT = 1.0 / T;
-  return {
-    alpha: Math.max(params.alpha * invT, 0.01),
-    beta: Math.max(params.beta * invT, 0.01),
-  };
-}
-
-/**
- * Draw one sample from the Beta posterior for each category.
- * Supports temperature scaling to adjust exploitation vs exploration.
+ * betaSample(alpha, beta) = gammaSample(alpha) / (gammaSample(alpha) + gammaSample(beta))
  *
- * Temperature (T):
- *   T = 1.0 (default) — Standard Thompson Sampling.
- *   T < 1.0 — Sharper distribution, favors high-reliability categories (exploit).
- *   T > 1.0 — Flatter distribution, increases uncertainty and exploration.
- *
- * Implementation: Scales alpha and beta by 1/T.
+ * This is the JS equivalent of Python's random.betavariate(alpha, beta).
+ * Used for Thompson Sampling action selection (explore via uncertainty).
  *
  * @param {Object} model - Model object containing categories
- * @param {number} temperature - Scaling factor (default 1.0)
  * @returns {Object} Map of category → float sample in [0, 1]
  */
-function samplePosteriors(model, temperature = 1.0) {
+function samplePosteriors(model) {
   const samples = {};
-
   for (const [cat, params] of Object.entries(model.categories || {})) {
-    const { alpha, beta } = getTemperatureScaledPosteriorParams(params, temperature);
-    samples[cat] = betaSample(alpha, beta);
+    samples[cat] = betaSample(
+      Math.max(params.alpha, 0.01),
+      Math.max(params.beta, 0.01),
+    );
   }
   return samples;
 }
@@ -471,7 +451,6 @@ module.exports = {
   getReliability,
   isCalibrated,
   getCalibration,
-  getTemperatureScaledPosteriorParams,
   samplePosteriors,
   argmaxPosteriors,
   pickBestCategory,