thumbgate 0.9.9 → 0.9.11

package/scripts/adk-consolidator.js

@@ -12,7 +12,6 @@
 
 const fs = require('fs');
 const path = require('path');
-const { GoogleGenAI } = require('@google/genai');
 
 const PROJECT_ROOT = path.join(__dirname, '..');
 const { getFeedbackPaths, readJSONL } = require('./feedback-loop');
@@ -22,7 +21,7 @@ const { trackEvent, shouldInjectReminder, injectReminder } = require('./reminder
 const { validateApiKey } = require('./billing');
 
 // Keep track of the last processed ID to avoid re-consolidating the exact same logs
-const STATE_FILE = process.env.ADK_STATE_FILE || path.join(PROJECT_ROOT, '.rlhf', 'adk-state.json');
+const STATE_FILE = process.env.ADK_STATE_FILE || path.join(PROJECT_ROOT, '.thumbgate', 'adk-state.json');
 
 function ensureDir(dirPath) {
   if (!fs.existsSync(dirPath)) {
@@ -91,7 +90,20 @@ async function consolidateMemory() {
     return;
   }
 
-  const ai = useFakeConsolidation ? null : new GoogleGenAI({ apiKey });
+  let ai = null;
+  if (!useFakeConsolidation) {
+    let GoogleGenAI;
+    try {
+      ({ GoogleGenAI } = require('@google/genai'));
+    } catch (error) {
+      if (error && error.code === 'MODULE_NOT_FOUND') {
+        console.warn('[ADK Consolidator] @google/genai is not installed. Skipping active consolidation.');
+        return;
+      }
+      throw error;
+    }
+    ai = new GoogleGenAI({ apiKey });
+  }
   const paths = getFeedbackPaths();
   const state = loadState();
 
@@ -193,7 +205,7 @@ Output ONLY valid JSON:
         if (shouldInjectReminder('guardrail_spike')) {
           const topRule = criticalInsights[0].rule;
           const reminderTurns = injectReminder([], 'guardrail_spike', { rule: topRule });
-          const reminderPath = path.join(PROJECT_ROOT, '.rlhf', `reminder_${Date.now()}.json`);
+          const reminderPath = path.join(PROJECT_ROOT, '.thumbgate', `reminder_${Date.now()}.json`);
           fs.writeFileSync(reminderPath, JSON.stringify(reminderTurns[0], null, 2));
           console.log(`[ADK Consolidator] Emitted system reminder: ${reminderPath}`);
         }
@@ -202,7 +214,7 @@ Output ONLY valid JSON:
       // Emit A2UI components (New Model)
       result.consolidatedInsights.forEach(insight => {
         const proposal = createRuleProposal(insight.pattern, insight.rule, insight.severity);
-        const a2uiPath = path.join(PROJECT_ROOT, '.rlhf', `a2ui_proposal_${Date.now()}.json`);
+        const a2uiPath = path.join(PROJECT_ROOT, '.thumbgate', `a2ui_proposal_${Date.now()}.json`);
         fs.writeFileSync(a2uiPath, JSON.stringify(proposal, null, 2));
         console.log(`[ADK Consolidator] Emitted A2UI Proposal: ${a2uiPath}`);
       });

package/scripts/agent-readiness.js

@@ -20,6 +20,8 @@ const WRITE_CAPABLE_TOOLS = new Set([
   'evaluate_context_pack',
   'generate_skill',
   'satisfy_gate',
+  'set_task_scope',
+  'approve_protected_action',
   'track_action',
   'register_claim_gate',
 ]);
@@ -29,7 +31,7 @@ const BOOTSTRAP_FILES = [
   { id: 'claude', path: 'CLAUDE.md', required: true },
   { id: 'gemini', path: 'GEMINI.md', required: true },
   { id: 'mcp', path: '.mcp.json', required: true },
-  { id: 'rlhfConfig', path: '.thumbgate/config.json', required: false },
+  { id: 'thumbgateConfig', path: '.thumbgate/config.json', required: false },
 ];
 
 const MCP_PROFILE_TIERS = {

package/scripts/agent-security-hardening.js

@@ -84,10 +84,10 @@ function getCredentialAudit({ periodHours = 24 } = {}) {
 
 // MCP profile tool allowlists (loaded from config or defaults)
 const PROFILE_ALLOWLISTS = {
-  essential: new Set(['capture_feedback', 'recall', 'search_lessons', 'search_rlhf', 'prevention_rules', 'enforcement_matrix', 'feedback_stats', 'estimate_uncertainty', 'org_dashboard']),
-  readonly: new Set(['recall', 'feedback_summary', 'search_lessons', 'verify_claim', 'gate_stats', 'search_rlhf', 'feedback_stats', 'estimate_uncertainty', 'org_dashboard']),
-  locked: new Set(['feedback_summary', 'search_lessons', 'diagnose_failure', 'list_intents', 'plan_intent', 'list_harnesses', 'verify_claim']),
-  commerce: new Set(['capture_feedback', 'recall', 'search_rlhf', 'commerce_recall', 'track_action', 'verify_claim', 'feedback_stats']),
+  essential: new Set(['capture_feedback', 'recall', 'search_lessons', 'search_thumbgate', 'prevention_rules', 'enforcement_matrix', 'feedback_stats', 'estimate_uncertainty', 'org_dashboard', 'set_task_scope', 'get_scope_state', 'set_branch_governance', 'get_branch_governance', 'approve_protected_action', 'check_operational_integrity']),
+  readonly: new Set(['recall', 'feedback_summary', 'search_lessons', 'verify_claim', 'gate_stats', 'search_thumbgate', 'feedback_stats', 'estimate_uncertainty', 'org_dashboard', 'get_scope_state', 'get_branch_governance', 'check_operational_integrity']),
+  locked: new Set(['feedback_summary', 'search_lessons', 'diagnose_failure', 'list_intents', 'plan_intent', 'list_harnesses', 'verify_claim', 'get_scope_state', 'get_branch_governance', 'check_operational_integrity']),
+  commerce: new Set(['capture_feedback', 'recall', 'search_thumbgate', 'commerce_recall', 'track_action', 'verify_claim', 'feedback_stats', 'set_task_scope', 'get_scope_state', 'set_branch_governance', 'get_branch_governance', 'approve_protected_action', 'check_operational_integrity']),
 };
 
 /**

package/scripts/auto-promote-gates.js

@@ -13,6 +13,14 @@ const WINDOW_DAYS = 30;
 const NEG_SIGNALS = new Set(['negative', 'negative_strong', 'down', 'thumbs_down']);
 
 function getFeedbackLogPath() {
+  if (process.env.THUMBGATE_FEEDBACK_DIR) {
+    return path.join(process.env.THUMBGATE_FEEDBACK_DIR, 'feedback-log.jsonl');
+  }
+  const localFallback = path.join(process.cwd(), '.thumbgate', 'feedback-log.jsonl');
+  const localClaude = path.join(process.cwd(), '.claude', 'memory', 'feedback', 'feedback-log.jsonl');
+  if (fs.existsSync(localFallback)) return localFallback;
+  if (fs.existsSync(localClaude)) return localClaude;
+  return localFallback; // default even if doesn't exist
   return path.join(resolveFeedbackDir(), 'feedback-log.jsonl');
 }
 

package/scripts/auto-wire-hooks.js

@@ -15,39 +15,31 @@
 
 const fs = require('fs');
 const path = require('path');
-
-const PKG_ROOT = path.join(__dirname, '..');
-
-function quoteShellPath(filePath) {
-  return `"${String(filePath).replace(/"/g, '\\"')}"`;
-}
+const {
+  cacheUpdateHookCommand,
+  preToolHookCommand,
+  sessionStartHookCommand,
+  statuslineCommand,
+  userPromptHookCommand,
+} = require('./hook-runtime');
 
 function getHome() {
   return process.env.HOME || process.env.USERPROFILE || '';
 }
 
 // --- Hook definitions ---
-
-function preToolHookCommand() {
-  return `bash ${quoteShellPath(path.join(PKG_ROOT, 'scripts', 'generate-pretool-hook.sh'))}`;
-}
-
-function userPromptHookCommand() {
-  return `bash ${quoteShellPath(path.join(PKG_ROOT, 'scripts', 'hook-auto-capture.sh'))}`;
-}
-
-function sessionStartHookCommand() {
-  return `bash ${quoteShellPath(path.join(PKG_ROOT, 'scripts', 'rlhf_session_start.sh'))}`;
-}
-
 const CLAUDE_HOOKS = {
   PreToolUse: {
-    matcher: 'Bash',
+    matcher: 'Bash|Edit|Write|MultiEdit',
     hooks: [{ type: 'command', command: preToolHookCommand() }],
   },
   UserPromptSubmit: {
     hooks: [{ type: 'command', command: userPromptHookCommand() }],
   },
+  PostToolUse: {
+    matcher: 'mcp__thumbgate__feedback_stats|mcp__thumbgate__dashboard',
+    hooks: [{ type: 'command', command: cacheUpdateHookCommand() }],
+  },
   SessionStart: {
     hooks: [{ type: 'command', command: sessionStartHookCommand() }],
   },
@@ -78,6 +70,10 @@ function claudeSettingsPath() {
   return path.join(getHome(), '.claude', 'settings.local.json');
 }
 
+function claudeSharedSettingsPath() {
+  return path.join(getHome(), '.claude', 'settings.json');
+}
+
 function loadJsonFile(filePath) {
   if (!fs.existsSync(filePath)) return null;
   try {
@@ -96,17 +92,67 @@ function hookAlreadyPresent(hookArray, command) {
   );
 }
 
+function pruneLegacyHookEntries(hookArray, expectedCommand, legacyPattern) {
+  if (!Array.isArray(hookArray)) {
+    return { hooks: [], removed: false };
+  }
+
+  let removed = false;
+  const hooks = hookArray.filter((entry) => {
+    const entryHooks = Array.isArray(entry && entry.hooks) ? entry.hooks : [];
+    const shouldRemove = entryHooks.some((hook) => {
+      const command = hook && typeof hook.command === 'string' ? hook.command : '';
+      return command !== expectedCommand && legacyPattern.test(command);
+    });
+    if (shouldRemove) {
+      removed = true;
+      return false;
+    }
+    return true;
+  });
+
+  return { hooks, removed };
+}
+
+function syncClaudeStatusLine(settingsPath, desiredStatusLine, dryRun) {
+  const settings = loadJsonFile(settingsPath) || {};
+  if (settings.statusLine && settings.statusLine.command === desiredStatusLine) {
+    return false;
+  }
+
+  settings.statusLine = { type: 'command', command: desiredStatusLine };
+  if (!dryRun) {
+    const dir = path.dirname(settingsPath);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+  }
+  return true;
+}
+
 function wireClaudeHooks(options) {
   const settingsPath = options.settingsPath || claudeSettingsPath();
+  const sharedSettingsPath = options.sharedSettingsPath || claudeSharedSettingsPath();
   const dryRun = options.dryRun || false;
+  const desiredStatusLine = statuslineCommand();
 
   let settings = loadJsonFile(settingsPath) || {};
   settings.hooks = settings.hooks || {};
 
   const added = [];
+  const legacyPatterns = {
+    PreToolUse: /(generate-pretool-hook\.sh|\bgate-check\b)/,
+    UserPromptSubmit: /(hook-auto-capture\.sh|hook-auto-capture\b)/,
+    PostToolUse: /(hook-thumbgate-cache-updater|cache-update\b)/,
+    SessionStart: /(thumbgate_session_start\.sh|session-start\b)/,
+  };
 
   for (const [lifecycle, hookDef] of Object.entries(CLAUDE_HOOKS)) {
     const hookCommand = hookDef.hooks[0].command;
+    const pruned = pruneLegacyHookEntries(settings.hooks[lifecycle], hookCommand, legacyPatterns[lifecycle]);
+    settings.hooks[lifecycle] = pruned.hooks;
+    if (pruned.removed) {
+      added.push({ lifecycle, command: `${hookCommand} (replaced legacy ThumbGate hook)` });
+    }
 
     if (hookAlreadyPresent(settings.hooks[lifecycle], hookCommand)) {
       continue;
@@ -122,15 +168,41 @@ function wireClaudeHooks(options) {
   }
 
   if (added.length === 0) {
-    return { changed: false, settingsPath, added: [] };
+    if (!settings.statusLine || settings.statusLine.command !== desiredStatusLine) {
+      if (!dryRun) {
+        const dir = path.dirname(settingsPath);
+        if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+      }
+      settings.statusLine = { type: 'command', command: desiredStatusLine };
+      if (!dryRun) {
+        fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+      }
+      const addedEntries = [{ lifecycle: 'statusLine', command: desiredStatusLine }];
+      if (syncClaudeStatusLine(sharedSettingsPath, desiredStatusLine, dryRun)) {
+        addedEntries.push({ lifecycle: 'statusLine', command: `${desiredStatusLine} (synced ~/.claude/settings.json)` });
+      }
+      return { changed: true, settingsPath, added: addedEntries };
+    }
+    const sharedStatusChanged = syncClaudeStatusLine(sharedSettingsPath, desiredStatusLine, dryRun);
+    return {
+      changed: sharedStatusChanged,
+      settingsPath,
+      added: sharedStatusChanged ? [{ lifecycle: 'statusLine', command: `${desiredStatusLine} (synced ~/.claude/settings.json)` }] : [],
+    };
   }
 
+  settings.statusLine = { type: 'command', command: desiredStatusLine };
+
   if (!dryRun) {
     const dir = path.dirname(settingsPath);
     if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
     fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
   }
 
+  if (syncClaudeStatusLine(sharedSettingsPath, desiredStatusLine, dryRun)) {
+    added.push({ lifecycle: 'statusLine', command: `${desiredStatusLine} (synced ~/.claude/settings.json)` });
+  }
+
   return { changed: true, settingsPath, added };
 }
 
@@ -151,6 +223,11 @@ function wireCodexHooks(options) {
   const preToolCmd = preToolHookCommand();
   const userPromptCmd = userPromptHookCommand();
 
+  const preToolPruned = pruneLegacyHookEntries(config.hooks.PreToolUse, preToolCmd, /(generate-pretool-hook\.sh|\bgate-check\b)/);
+  config.hooks.PreToolUse = preToolPruned.hooks;
+  const userPromptPruned = pruneLegacyHookEntries(config.hooks.UserPromptSubmit, userPromptCmd, /(hook-auto-capture\.sh|hook-auto-capture\b)/);
+  config.hooks.UserPromptSubmit = userPromptPruned.hooks;
+
   if (!hookAlreadyPresent(config.hooks.PreToolUse, preToolCmd)) {
     config.hooks.PreToolUse = config.hooks.PreToolUse || [];
     config.hooks.PreToolUse.push({
@@ -198,6 +275,11 @@ function wireGeminiHooks(options) {
   const preToolCmd = preToolHookCommand();
   const userPromptCmd = userPromptHookCommand();
 
+  const preToolPruned = pruneLegacyHookEntries(settings.hooks.PreToolUse, preToolCmd, /(generate-pretool-hook\.sh|\bgate-check\b)/);
+  settings.hooks.PreToolUse = preToolPruned.hooks;
+  const userPromptPruned = pruneLegacyHookEntries(settings.hooks.UserPromptSubmit, userPromptCmd, /(hook-auto-capture\.sh|hook-auto-capture\b)/);
+  settings.hooks.UserPromptSubmit = userPromptPruned.hooks;
+
   if (!hookAlreadyPresent(settings.hooks.PreToolUse, preToolCmd)) {
     settings.hooks.PreToolUse = settings.hooks.PreToolUse || [];
     settings.hooks.PreToolUse.push({
@@ -286,8 +368,10 @@ module.exports = {
   loadJsonFile,
   parseFlags,
   claudeSettingsPath,
+  claudeSharedSettingsPath,
   codexConfigPath,
   geminiSettingsPath,
+  syncClaudeStatusLine,
   CLAUDE_HOOKS,
   preToolHookCommand,
   userPromptHookCommand,

package/scripts/billing.js

@@ -16,12 +16,11 @@ function withTimeout(promise, ms = STRIPE_TIMEOUT_MS) {
 const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
-const Stripe = require('stripe');
 const { createTraceId } = require('./hosted-config');
 const {
   getFeedbackPaths,
   getLegacyFeedbackDir,
-  getRlhfFeedbackDir,
+  getFallbackFeedbackDir,
   resolveFallbackArtifactPath,
 } = require('./feedback-paths');
 const { getTelemetryAnalytics, getTelemetrySourceDiagnostics } = require('./telemetry-analytics');
@@ -71,6 +70,9 @@ const CONFIG = {
   get LOCAL_CHECKOUT_SESSIONS_PATH() {
     return process.env._TEST_LOCAL_CHECKOUT_SESSIONS_PATH || path.join(getFeedbackPaths().FEEDBACK_DIR, 'local-checkout-sessions.json');
   },
+  get NEWSLETTER_SUBSCRIBERS_PATH() {
+    return process.env._TEST_NEWSLETTER_SUBSCRIBERS_PATH || path.join(getFeedbackPaths().FEEDBACK_DIR, 'newsletter-subscribers.jsonl');
+  },
   CREDIT_PACKS: {
     'mistake-free-starter': {
       id: 'mistake-free-starter',
@@ -89,11 +91,27 @@ function resolveLegacyBillingPath(fileName) {
 }
 
 let _stripeClient = null;
+let _stripeCtor = null;
+
+function getStripeConstructor() {
+  if (_stripeCtor) return _stripeCtor;
+  try {
+    _stripeCtor = require('stripe');
+    return _stripeCtor;
+  } catch (error) {
+    if (error && error.code === 'MODULE_NOT_FOUND') {
+      throw new Error('stripe package is not installed. Live billing features are unavailable.');
+    }
+    throw error;
+  }
+}
+
 function getStripeClient() {
   if (!_stripeClient) {
     if (!CONFIG.STRIPE_SECRET_KEY) {
       throw new Error('STRIPE_SECRET_KEY is missing. Stripe client cannot be initialized.');
     }
+    const Stripe = getStripeConstructor();
     _stripeClient = new Stripe(CONFIG.STRIPE_SECRET_KEY);
   }
   return _stripeClient;
@@ -297,6 +315,11 @@ function buildBillingSourceDiagnostics(feedbackDir) {
     legacyPath: resolveLegacyBillingPath('local-checkout-sessions.json'),
     mode: 'fallback',
   });
+  const newsletterSubscribers = describeDataFile({
+    primaryPath: CONFIG.NEWSLETTER_SUBSCRIBERS_PATH,
+    legacyPath: resolveLegacyBillingPath('newsletter-subscribers.jsonl'),
+    mode: 'fallback',
+  });
   const telemetry = getTelemetrySourceDiagnostics(feedbackDir);
   const warnings = [
     ...telemetry.warnings,
@@ -338,7 +361,7 @@ function buildBillingSourceDiagnostics(feedbackDir) {
     ));
   }
 
-  const mixedRoots = [keyStore, funnelLedger, revenueLedger, checkoutSessions, telemetry]
+  const mixedRoots = [keyStore, funnelLedger, revenueLedger, checkoutSessions, newsletterSubscribers, telemetry]
     .some((descriptor) => descriptor.mixedRoots || descriptor.activeMode === 'legacy_fallback');
   if (mixedRoots) {
     warnings.push(buildSourceWarning(
@@ -349,7 +372,7 @@ function buildBillingSourceDiagnostics(feedbackDir) {
 
   return {
     feedbackDir,
-    rlhfFeedbackDir: getRlhfFeedbackDir(),
+    fallbackFeedbackDir: getFallbackFeedbackDir(),
     legacyFeedbackDir: getLegacyFeedbackDir(),
     mixedRoots,
     files: {
@@ -357,6 +380,7 @@ function buildBillingSourceDiagnostics(feedbackDir) {
       funnelLedger,
       revenueLedger,
       checkoutSessions,
+      newsletterSubscribers,
       telemetry,
     },
     warnings,
@@ -622,6 +646,13 @@ function loadRevenueLedger() {
   );
 }
 
+function loadNewsletterSubscribers() {
+  return loadJsonlRecords(
+    CONFIG.NEWSLETTER_SUBSCRIBERS_PATH,
+    resolveLegacyBillingPath('newsletter-subscribers.jsonl')
+  );
+}
+
 function resolveRevenueLedgerFilePath() {
   const primary = CONFIG.REVENUE_LEDGER_PATH;
   const legacy = resolveLegacyBillingPath('revenue-events.jsonl');
@@ -1331,6 +1362,11 @@ function getBusinessAnalytics(options = {}) {
     analyticsWindow,
     (entry) => entry && entry.submittedAt
   );
+  const newsletterSubscribers = filterEntriesForWindow(
+    loadNewsletterSubscribers(),
+    analyticsWindow,
+    (entry) => entry && entry.subscribedAt
+  );
   const funnel = getFunnelAnalytics({ ...analyticsWindow, extraRevenueEvents });
   const acquisitionEvents = events.filter((entry) => entry && entry.stage === 'acquisition');
   const paidEvents = events.filter((entry) => entry && entry.stage === 'paid');
@@ -1544,6 +1580,17 @@ function getBusinessAnalytics(options = {}) {
   let workflowSprintLeadLatestAt = null;
   let workflowSprintLeadContactable = 0;
   let qualifiedWorkflowSprintLeadCount = 0;
+  const newsletterBySource = {};
+  const newsletterByCampaign = {};
+  const newsletterByCreator = {};
+  const newsletterByCommunity = {};
+  const newsletterByPostId = {};
+  const newsletterByCommentId = {};
+  const newsletterByCampaignVariant = {};
+  const newsletterByOfferCode = {};
+  const newsletterSubscriberKeys = new Set();
+  let newsletterLatest = null;
+  let newsletterLatestAt = null;
 
   for (const entry of workflowSprintLeads) {
     if (!entry || typeof entry !== 'object') continue;
@@ -1584,6 +1631,46 @@ function getBusinessAnalytics(options = {}) {
     }
   }
 
+  for (const entry of newsletterSubscribers) {
+    if (!entry || typeof entry !== 'object') continue;
+    const attribution = extractAttribution({
+      ...sanitizeMetadata(entry.attribution || {}),
+      ...sanitizeMetadata(entry),
+    });
+    incrementCounter(newsletterBySource, resolveAttributionSource(attribution, entry.source || 'newsletter'));
+    incrementCounter(newsletterByCampaign, resolveAttributionCampaign(attribution));
+    incrementCounter(newsletterByCreator, attribution.creator);
+    incrementCounter(newsletterByCommunity, attribution.community);
+    incrementCounter(newsletterByPostId, attribution.postId);
+    incrementCounter(newsletterByCommentId, attribution.commentId);
+    incrementCounter(newsletterByCampaignVariant, attribution.campaignVariant);
+    incrementCounter(newsletterByOfferCode, attribution.offerCode);
+
+    newsletterSubscriberKeys.add(
+      pickFirstText(
+        entry.email,
+        entry.acquisitionId,
+        entry.visitorId,
+        entry.sessionId,
+        entry.subscribedAt
+      )
+    );
+
+    if (!newsletterLatestAt || String(entry.subscribedAt || '') > newsletterLatestAt) {
+      newsletterLatestAt = entry.subscribedAt || null;
+      newsletterLatest = {
+        email: entry.email || null,
+        subscribedAt: entry.subscribedAt || null,
+        source: resolveAttributionSource(attribution, entry.source || 'newsletter'),
+        campaign: resolveAttributionCampaign(attribution),
+        creator: attribution.creator || null,
+        community: attribution.community || null,
+        landingPath: pickFirstText(entry.landingPath, attribution.landingPath),
+        referrerHost: entry.referrerHost || null,
+      };
+    }
+  }
+
   const unreconciledPaidEvents = paidEvents.filter((entry) => {
     const eventKey = resolvePaidProviderEventKey(entry);
     if (!eventKey) return true;
@@ -1603,6 +1690,7 @@ function getBusinessAnalytics(options = {}) {
     checkoutLookupFailures: telemetry.ctas ? telemetry.ctas.lookupFailures || 0 : 0,
     buyerLossFeedback: telemetry.buyerLoss ? telemetry.buyerLoss.totalSignals || 0 : 0,
     seoLandingViews: telemetry.seo ? telemetry.seo.landingViews || 0 : 0,
+    newsletterSignups: newsletterSubscribers.length,
   };
 
   const operatorGeneratedAcquisition = {
@@ -1632,6 +1720,7 @@ function getBusinessAnalytics(options = {}) {
       tracksInvoices: false,
       tracksAttribution: true,
       tracksWorkflowSprintLeads: true,
+      tracksNewsletterSubscribers: true,
       providerCoverage: {
         stripe: processorReconciledOrders > 0 ? 'booked_revenue+processor_reconciled' : 'booked_revenue',
         githubMarketplace: 'webhook_or_configured_plan_prices',
@@ -1701,6 +1790,20 @@ function getBusinessAnalytics(options = {}) {
         byCreator: qualifiedWorkflowSprintLeadByCreator,
       },
     },
+    newsletter: {
+      total: newsletterSubscribers.length,
+      uniqueSubscribers: newsletterSubscriberKeys.size,
+      bySource: newsletterBySource,
+      byCampaign: newsletterByCampaign,
+      byCreator: newsletterByCreator,
+      byCommunity: newsletterByCommunity,
+      byPostId: newsletterByPostId,
+      byCommentId: newsletterByCommentId,
+      byCampaignVariant: newsletterByCampaignVariant,
+      byOfferCode: newsletterByOfferCode,
+      latestSubscribedAt: newsletterLatestAt,
+      latestSubscriber: newsletterLatest,
+    },
     attribution: {
       acquisitionBySource: signupsBySource,
       acquisitionByCampaign: signupsByCampaign,
@@ -1822,6 +1925,7 @@ function getBillingSummary(options = {}) {
     signups: business.signups,
     revenue: business.revenue,
     pipeline: business.pipeline,
+    newsletter: business.newsletter,
     attribution: business.attribution,
     trafficMetrics: business.trafficMetrics,
     operatorGeneratedAcquisition: business.operatorGeneratedAcquisition,
@@ -2078,7 +2182,7 @@ function provisionApiKey(customerId, opts = {}) {
     return { key, customerId, createdAt: meta.createdAt, installId: meta.installId || null, reused: true, remainingCredits: meta.remainingCredits };
   }
 
-  const key = `rlhf_${crypto.randomBytes(16).toString('hex')}`;
+  const key = `tg_${crypto.randomBytes(16).toString('hex')}`;
   const createdAt = new Date().toISOString();
   store.keys[key] = {
     customerId,
@@ -2101,7 +2205,7 @@ function rotateApiKey(oldKey) {
 
   meta.active = false;
   meta.disabledAt = new Date().toISOString();
-  const newKey = `rlhf_${crypto.randomBytes(16).toString('hex')}`;
+  const newKey = `tg_${crypto.randomBytes(16).toString('hex')}`;
   store.keys[newKey] = {
     customerId: meta.customerId,
     active: true,
@@ -2426,7 +2530,7 @@ function handleGithubWebhook(event) {
 }
 
 module.exports = {
-  CONFIG, createCheckoutSession, getCheckoutSessionStatus, provisionApiKey, rotateApiKey, validateApiKey, recordUsage, disableCustomerKeys, handleWebhook, verifyWebhookSignature, verifyGithubWebhookSignature, handleGithubWebhook, loadKeyStore, appendFunnelEvent, appendRevenueEvent, loadFunnelLedger, loadRevenueLedger, loadResolvedRevenueEvents, getFunnelAnalytics, getBusinessAnalytics, getBillingSummary, getBillingSummaryLive, listStripeReconciledRevenueEvents, repairGithubMarketplaceRevenueLedger,
+  CONFIG, createCheckoutSession, getCheckoutSessionStatus, provisionApiKey, rotateApiKey, validateApiKey, recordUsage, disableCustomerKeys, handleWebhook, verifyWebhookSignature, verifyGithubWebhookSignature, handleGithubWebhook, loadKeyStore, appendFunnelEvent, appendRevenueEvent, loadFunnelLedger, loadRevenueLedger, loadNewsletterSubscribers, loadResolvedRevenueEvents, getFunnelAnalytics, getBusinessAnalytics, getBillingSummary, getBillingSummaryLive, listStripeReconciledRevenueEvents, repairGithubMarketplaceRevenueLedger,
   _buildCheckoutSessionPayload: buildCheckoutSessionPayload,
   _resolveSubscriptionCheckoutSelection: resolveSubscriptionCheckoutSelection,
   _API_KEYS_PATH: () => CONFIG.API_KEYS_PATH,

package/scripts/build-metadata.js

@@ -3,6 +3,8 @@ const path = require('path');
 
 const PROJECT_ROOT = path.resolve(__dirname, '..');
 const DEFAULT_BUILD_METADATA_PATH = path.join(PROJECT_ROOT, 'config', 'build-metadata.json');
+const BUILD_SHA_ENV_KEY = 'THUMBGATE_BUILD_SHA';
+const BUILD_GENERATED_AT_ENV_KEY = 'THUMBGATE_BUILD_GENERATED_AT';
 
 function normalizeNullableText(value) {
   if (typeof value !== 'string') {
@@ -18,6 +20,16 @@ function resolveBuildMetadata({ env = process.env, filePath } = {}) {
     normalizeNullableText(filePath) ||
     normalizeNullableText(env.THUMBGATE_BUILD_METADATA_PATH) ||
     DEFAULT_BUILD_METADATA_PATH;
+  const envBuildSha = normalizeNullableText(env[BUILD_SHA_ENV_KEY]);
+  const envGeneratedAt = normalizeNullableText(env[BUILD_GENERATED_AT_ENV_KEY]);
+
+  if (envBuildSha || envGeneratedAt) {
+    return {
+      path: resolvedPath,
+      buildSha: envBuildSha,
+      generatedAt: envGeneratedAt,
+    };
+  }
 
   try {
     const parsed = JSON.parse(fs.readFileSync(resolvedPath, 'utf8'));
@@ -91,6 +103,8 @@ if (require.main === module) {
 }
 
 module.exports = {
+  BUILD_GENERATED_AT_ENV_KEY,
+  BUILD_SHA_ENV_KEY,
   DEFAULT_BUILD_METADATA_PATH,
   resolveBuildMetadata,
   writeBuildMetadataFile,

package/scripts/check-congruence.js

@@ -126,7 +126,7 @@ async function main() {
     'README.md contains unresolved merge conflict markers'
   );
   check(
-    landingHtml.includes('doesn\'t touch the model') || landingHtml.includes('different from RLHF-the-concept'),
+    landingHtml.includes('doesn\'t touch the model') || landingHtml.includes('different from model-training feedback loops'),
     'public/index.html missing honest disclaimer (FAQ or inline)'
   );
   check(

package/scripts/context-engine.js

@@ -9,6 +9,7 @@
  * topical bundles and route queries to the most relevant subset. This reduces
  * MCP tool calls and context window consumption.
  *
+ * Ported from Subway_RN_Demo/scripts/context-engine.js for ThumbGate.
  * Ported from Subway_RN_Demo/scripts/context-engine.js for thumbgate.
  * PATH: PROJECT_ROOT = path.join(__dirname, '..') — 1 level up from scripts/
  */
@@ -311,7 +312,7 @@ function routeQuery(query, indexPath, topN) {
   if (lowerQuery.includes('build') || lowerQuery.includes('ci')) intentBoost = 'ci-cd';
   if (lowerQuery.includes('security') || lowerQuery.includes('audit')) intentBoost = 'security';
   if (lowerQuery.includes('mobile') || lowerQuery.includes('android')) intentBoost = 'mobile-dev';
-  if (lowerQuery.includes('memory') || lowerQuery.includes('rlhf')) intentBoost = 'mcp-ai';
+  if (lowerQuery.includes('memory') || lowerQuery.includes('thumbgate')) intentBoost = 'mcp-ai';
 
   // Step 2: Contextual Ranking
   const queryTokens = query

package/scripts/daemon-manager.js

@@ -6,11 +6,11 @@ const path = require('path');
 const { execSync } = require('child_process');
 const os = require('os');
 
-const LABEL = 'com.thumbgate.thumbgate';
+const LABEL = 'com.thumbgate.daemon';
 const PLIST_PATH = path.join(os.homedir(), 'Library', 'LaunchAgents', `${LABEL}.plist`);
 const NODE_PATH = process.execPath;
 const GATEWAY_BIN = path.join(__dirname, '..', 'bin', 'cli.js');
-const LOG_DIR = path.join(os.homedir(), '.rlhf', 'logs');
+const LOG_DIR = path.join(os.homedir(), '.thumbgate', 'logs');
 
 function generatePlist() {
   return `<?xml version="1.0" encoding="UTF-8"?>

package/scripts/dashboard.js

@@ -105,7 +105,7 @@ function computeGateStats() {
   const autoGatesPath = getAutoGatesPath();
   const statsPath = path.join(
     process.env.HOME || '/tmp',
-    '.rlhf',
+    '.thumbgate',
     'gate-stats.json'
   );
   const stats = readJsonFile(statsPath) || { blocked: 0, warned: 0, passed: 0, byGate: {} };
@@ -828,7 +828,7 @@ function printDashboard(data) {
     : '\u2192';
 
   console.log('');
-  console.log('\uD83D\uDCCA RLHF Dashboard');
+  console.log('\uD83D\uDCCA ThumbGate Dashboard');
   console.log('\u2550'.repeat(46));
   console.log(`  Approval Rate    : ${approval.approvalRate}% \u2192 ${approval.recentRate}% (7-day trend ${trendArrow})`);
   console.log(`  Total Signals    : ${approval.total} (${approval.positive} positive, ${approval.negative} negative)`);

package/scripts/data-governance.js

@@ -136,7 +136,7 @@ function enforceRetention() {
  */
 function generateDataUsageSummary() {
   const prefs = loadPreferences();
-  const feedbackDir = process.env.THUMBGATE_FEEDBACK_DIR || path.join(process.cwd(), '.rlhf');
+  const feedbackDir = process.env.THUMBGATE_FEEDBACK_DIR || path.join(process.cwd(), '.thumbgate');
   const logPath = path.join(feedbackDir, 'feedback-log.jsonl');
   let entryCount = 0;
   if (fs.existsSync(logPath)) {