thumbgate 0.9.10 → 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');
@@ -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();
 

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_thumbgate', 'prevention_rules', 'enforcement_matrix', 'feedback_stats', 'estimate_uncertainty', 'org_dashboard']),
-  readonly: new Set(['recall', 'feedback_summary', 'search_lessons', 'verify_claim', 'gate_stats', 'search_thumbgate', '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_thumbgate', '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

@@ -3,6 +3,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const { resolveFeedbackDir } = require('./feedback-paths');
 
 const MAX_AUTO_GATES = 10;
 const WARN_THRESHOLD = 3; // 3+ repeated failures surface a warning gate
@@ -20,6 +21,7 @@ function getFeedbackLogPath() {
   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');
 }
 
 function getAutoGatesPath() {

package/scripts/auto-wire-hooks.js

@@ -15,35 +15,31 @@
 
 const fs = require('fs');
 const path = require('path');
-
-const PKG_ROOT = path.join(__dirname, '..');
+const {
+  cacheUpdateHookCommand,
+  preToolHookCommand,
+  sessionStartHookCommand,
+  statuslineCommand,
+  userPromptHookCommand,
+} = require('./hook-runtime');
 
 function getHome() {
   return process.env.HOME || process.env.USERPROFILE || '';
 }
 
 // --- Hook definitions ---
-
-function preToolHookCommand() {
-  return 'bash scripts/generate-pretool-hook.sh';
-}
-
-function userPromptHookCommand() {
-  return 'bash scripts/hook-auto-capture.sh';
-}
-
-function sessionStartHookCommand() {
-  return 'bash scripts/thumbgate_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() }],
   },
@@ -74,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 {
@@ -92,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;
@@ -118,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 };
 }
 
@@ -147,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({
@@ -194,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({
@@ -282,8 +368,10 @@ module.exports = {
   loadJsonFile,
   parseFlags,
   claudeSettingsPath,
+  claudeSharedSettingsPath,
   codexConfigPath,
   geminiSettingsPath,
+  syncClaudeStatusLine,
   CLAUDE_HOOKS,
   preToolHookCommand,
   userPromptHookCommand,

package/scripts/behavioral-extraction.js

@@ -8,13 +8,9 @@
 
 const fs = require('fs');
 const path = require('path');
+const { resolveFeedbackDir } = require('./feedback-paths');
 
-const HOME = process.env.HOME || process.env.USERPROFILE || '';
-const envDir = process.env.THUMBGATE_FEEDBACK_DIR;
-const localFallback = path.join(process.cwd(), '.thumbgate');
-const localClaude = path.join(process.cwd(), '.claude', 'memory', 'feedback');
-const baseDir = envDir || (fs.existsSync(localFallback) ? localFallback : localClaude);
-
+const baseDir = resolveFeedbackDir();
 const FEEDBACK_LOG_PATH = path.join(baseDir, 'feedback-log.jsonl');
 const TRAITS_PATH = path.join(baseDir, 'behavioral-traits.json');
 

package/scripts/billing.js

@@ -16,7 +16,6 @@ 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,
@@ -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(
@@ -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,
@@ -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/budget-guard.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 const fs = require('fs');
 const path = require('path');
+const { resolveFeedbackDir } = require('./feedback-paths');
 
-const PROJECT_ROOT = path.join(__dirname, '..');
-const FEEDBACK_DIR = process.env.THUMBGATE_FEEDBACK_DIR || path.join(PROJECT_ROOT, '.claude', 'memory', 'feedback');
+const FEEDBACK_DIR = resolveFeedbackDir();
 const LEDGER_PATH = path.join(FEEDBACK_DIR, 'budget-ledger.json');
 const LOCK_PATH = `${LEDGER_PATH}.lock`;
 

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/context-engine.js

@@ -10,6 +10,7 @@
  * 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/
  */
 

package/scripts/deploy-policy.js

@@ -39,24 +39,10 @@ const PROFILE_DEFS = {
   },
 };
 
-const ENV_ALIASES = {
-  THUMBGATE_API_KEY: ['THUMBGATE_API_KEY', 'RLHF_API_KEY'],
-  THUMBGATE_API_KEY_ROTATED_AT: ['THUMBGATE_API_KEY_ROTATED_AT', 'RLHF_API_KEY_ROTATED_AT'],
-  THUMBGATE_PUBLIC_APP_ORIGIN: ['THUMBGATE_PUBLIC_APP_ORIGIN', 'RLHF_PUBLIC_APP_ORIGIN'],
-  THUMBGATE_BILLING_API_BASE_URL: [
-    'THUMBGATE_BILLING_API_BASE_URL',
-    'RLHF_BILLING_API_BASE_URL',
-    'THUMBGATE_CANONICAL_API_BASE_URL',
-  ],
-};
-
 function resolveEnvValue(name, env = process.env) {
-  const aliases = ENV_ALIASES[name] || [name];
-  for (const alias of aliases) {
-    const value = String(env[alias] || '').trim();
-    if (value) {
-      return value;
-    }
+  const value = String(env[name] || '').trim();
+  if (value) {
+    return value;
   }
 
   if (name === 'THUMBGATE_PUBLIC_APP_ORIGIN') {

package/scripts/dpo-optimizer.js

@@ -13,8 +13,8 @@
 
 const fs = require('fs');
 const path = require('path');
-const os = require('os');
 const { getEffectiveSetting } = require('./evolution-state');
+const { resolveFeedbackDir } = require('./feedback-paths');
 
 const DPO_BETA = 0.1;
 
@@ -154,11 +154,8 @@ function applyDpoAdjustments(modelPath, pairs) {
  */
 function run(opts) {
   const options = opts || {};
-  const feedbackDir = options.feedbackDir ||
-    process.env.THUMBGATE_FEEDBACK_DIR ||
-    path.join(os.homedir(), '.claude', 'memory', 'feedback');
-  const modelPath = options.modelPath ||
-    path.join(process.cwd(), '.claude', 'memory', 'feedback', 'feedback_model.json');
+  const feedbackDir = options.feedbackDir || resolveFeedbackDir();
+  const modelPath = options.modelPath || path.join(feedbackDir, 'feedback_model.json');
 
   const pairs = buildPreferencePairs(feedbackDir);