thumbgate 0.9.9 → 0.9.11

package/scripts/generate-paperbanana-diagrams.sh

@@ -48,7 +48,7 @@ budget_check() {
 
 mkdir -p docs/diagrams
 
-cat > docs/diagrams/rlhf-architecture.txt <<'TXT'
+cat > docs/diagrams/thumbgate-architecture.txt <<'TXT'
 The system starts when a user gives explicit thumbs up/down feedback. A capture layer enriches the signal with context and tags.
 An action resolver maps the signal to store-learning, store-mistake, or no-action.
 A schema validator enforces strict structure before memory promotion.
@@ -73,14 +73,14 @@ TXT
 
 budget_check "$PB_ESTIMATE_PER_DIAGRAM"
 paperbanana generate \
-  --input docs/diagrams/rlhf-architecture.txt \
+  --input docs/diagrams/thumbgate-architecture.txt \
   --caption "ThumbGate architecture for AI coding agents with schema gate, memory store, prevention rules, and DPO export" \
   --vlm-provider gemini \
   --vlm-model "$PB_VLM_MODEL" \
   --image-provider google_imagen \
   --image-model "$PB_IMAGE_MODEL" \
   --iterations "$PB_MAX_ITERATIONS" \
-  --output docs/diagrams/rlhf-architecture.png
+  --output docs/diagrams/thumbgate-architecture.png
 node scripts/budget-guard.js --add="$PB_ESTIMATE_PER_DIAGRAM" --source=paperbanana --note="architecture-overview"
 
 budget_check "$PB_ESTIMATE_PER_DIAGRAM"

package/scripts/github-about.js

@@ -79,7 +79,7 @@ function buildCanonicalRepoUrls(about) {
     licenseUrl: `${about.repositoryUrl}/blob/main/LICENSE`,
     quickStartUrl: `${about.repositoryUrl}#quick-start`,
     pluginsUrl: `${about.repositoryUrl}/tree/main/plugins`,
-    readmeImageUrl: `https://raw.githubusercontent.com/${about.repo}/main/docs/diagrams/rlhf-architecture-pb.png`,
+    readmeImageUrl: `https://raw.githubusercontent.com/${about.repo}/main/docs/diagrams/thumbgate-architecture-pb.png`,
     verificationEvidenceUrl: `${about.repositoryUrl}/blob/main/docs/VERIFICATION_EVIDENCE.md`,
     compatibilityReportUrl: `${about.repositoryUrl}/blob/main/proof/compatibility/report.json`,
     automationReportUrl: `${about.repositoryUrl}/blob/main/proof/automation/report.json`,

package/scripts/gtm-revenue-loop.js

@@ -4,13 +4,20 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const { spawnSync } = require('node:child_process');
-const { GoogleGenAI } = require('@google/genai');
 const { resolveHostedBillingConfig } = require('./hosted-config');
 const { getOperationalBillingSummary } = require('./operational-summary');
 
 const COMMERCIAL_TRUTH_LINK = 'https://github.com/IgorGanapolsky/ThumbGate/blob/main/docs/COMMERCIAL_TRUTH.md';
 const VERIFICATION_EVIDENCE_LINK = 'https://github.com/IgorGanapolsky/ThumbGate/blob/main/docs/VERIFICATION_EVIDENCE.md';
 
+function getGoogleGenAI() {
+  try {
+    return require('@google/genai').GoogleGenAI;
+  } catch {
+    return null;
+  }
+}
+
 function parseArgs(argv = []) {
   const options = {
     maxTargets: 6,
@@ -310,6 +317,18 @@ async function generateOutreachMessages(targets, motionCatalog = buildMotionCata
     });
   }
 
+  const GoogleGenAI = getGoogleGenAI();
+  if (!GoogleGenAI) {
+    return targets.map((target) => {
+      const selectedMotion = selectOutreachMotion(target, motionCatalog);
+      return {
+        ...target,
+        selectedMotion,
+        message: buildFallbackMessage(target, selectedMotion, motionCatalog),
+      };
+    });
+  }
+
   const ai = new GoogleGenAI({ apiKey });
   const results = [];
 

package/scripts/hook-runtime.js

@@ -0,0 +1,89 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const {
+  isSourceCheckout,
+  publishedCliAvailable,
+} = require('./mcp-config');
+const { runPublishedCliHelp, publishedCliArgs } = require('./published-cli');
+
+const PKG_ROOT = path.join(__dirname, '..');
+const featureSupportCache = new Map();
+
+function packageVersion() {
+  const pkg = JSON.parse(fs.readFileSync(path.join(PKG_ROOT, 'package.json'), 'utf8'));
+  return pkg.version;
+}
+
+function shellQuote(value) {
+  return JSON.stringify(String(value));
+}
+
+function publishedHookCommandsAvailable(version) {
+  if (!publishedCliAvailable(version)) {
+    return false;
+  }
+  if (featureSupportCache.has(version)) {
+    return featureSupportCache.get(version);
+  }
+
+  let available = false;
+  try {
+    const helpText = runPublishedCliHelp(version, { timeout: 8000 });
+    available = ['gate-check', 'cache-update', 'statusline-render', 'hook-auto-capture', 'session-start']
+      .every((command) => helpText.includes(command));
+  } catch {
+    available = false;
+  }
+
+  featureSupportCache.set(version, available);
+  return available;
+}
+
+function resolveCliBaseCommand() {
+  const version = packageVersion();
+  if (publishedHookCommandsAvailable(version)) {
+    return `npx ${publishedCliArgs(version).map(shellQuote).join(' ')}`;
+  }
+  if (isSourceCheckout(PKG_ROOT)) {
+    return `node ${shellQuote(path.join(PKG_ROOT, 'bin', 'cli.js'))}`;
+  }
+  return `npx -y thumbgate@${version}`;
+}
+
+function buildPortableHookCommand(subcommand) {
+  return `${resolveCliBaseCommand()} ${subcommand}`;
+}
+
+function preToolHookCommand() {
+  return buildPortableHookCommand('gate-check');
+}
+
+function userPromptHookCommand() {
+  return buildPortableHookCommand('hook-auto-capture');
+}
+
+function sessionStartHookCommand() {
+  return buildPortableHookCommand('session-start');
+}
+
+function cacheUpdateHookCommand() {
+  return buildPortableHookCommand('cache-update');
+}
+
+function statuslineCommand() {
+  return buildPortableHookCommand('statusline-render');
+}
+
+module.exports = {
+  buildPortableHookCommand,
+  cacheUpdateHookCommand,
+  packageVersion,
+  publishedHookCommandsAvailable,
+  preToolHookCommand,
+  resolveCliBaseCommand,
+  sessionStartHookCommand,
+  statuslineCommand,
+  userPromptHookCommand,
+};

package/scripts/hook-stop-self-score.sh

@@ -18,9 +18,9 @@ node -e '
   const path = require("path");
 
   // Resolve modules relative to ThumbGate package root
-  const rlhfRoot = process.env.THUMBGATE_ROOT;
-  const { selfAuditAndLog } = require(path.join(rlhfRoot, "scripts", "rlaif-self-audit"));
-  const { getFeedbackPaths } = require(path.join(rlhfRoot, "scripts", "feedback-loop"));
+  const thumbgateRoot = process.env.THUMBGATE_ROOT;
+  const { selfAuditAndLog } = require(path.join(thumbgateRoot, "scripts", "rlaif-self-audit"));
+  const { getFeedbackPaths } = require(path.join(thumbgateRoot, "scripts", "feedback-loop"));
 
   const stopReason = process.env.CLAUDE_STOP_REASON || "unknown";
 

package/scripts/hook-thumbgate-cache-updater.js

@@ -1,48 +1,109 @@
 #!/usr/bin/env node
+'use strict';
+
 /**
- * PostToolUse hook: updates ThumbGate statusline cache after feedback_stats calls.
- * Installed by: npx thumbgate init --agent claude-code
+ * PostToolUse hook: updates ThumbGate statusline cache after dashboard/stat calls.
+ * Also used directly by the CLI to refresh statusline counters after feedback capture.
  */
-'use strict';
+
 const fs = require('fs');
 const path = require('path');
 const { resolveFeedbackDir } = require('./feedback-paths');
 
-const CACHE_PATH = path.join(resolveFeedbackDir(), 'statusline_cache.json');
+function getCachePath() {
+  return path.join(resolveFeedbackDir(), 'statusline_cache.json');
+}
 
-let input = '';
-process.stdin.setEncoding('utf8');
-process.stdin.on('data', chunk => { input += chunk; });
-process.stdin.on('end', () => {
+function readExistingCache(cachePath = getCachePath()) {
   try {
-    const event = JSON.parse(input);
-    const tool = event.tool_name || '';
-    if (tool !== 'mcp__rlhf__feedback_stats' && tool !== 'mcp__rlhf__dashboard') return;
-
-    const raw = event.tool_response;
-    if (!raw) return;
-    const data = typeof raw === 'string' ? JSON.parse(raw) : raw;
-
-    const cache = {};
-    if (tool === 'mcp__rlhf__feedback_stats') {
-      cache.thumbs_up = String(data.totalPositive || 0);
-      cache.thumbs_down = String(data.totalNegative || 0);
-      cache.lessons = String((data.rubric || {}).samples || 0);
-      cache.approval_rate = String(Math.round((data.approvalRate || 0) * 1000) / 10);
-      cache.trend = data.trend || '?';
-      cache.total_feedback = String(data.total || 0);
-    } else if (tool === 'mcp__rlhf__dashboard') {
-      const approval = data.approval || {};
-      cache.thumbs_up = String(approval.totalPositive || 0);
-      cache.thumbs_down = String(approval.totalNegative || 0);
-      cache.lessons = String((data.rubric || {}).samples || 0);
-      cache.approval_rate = String(approval.approvalRate || '?');
-      cache.trend = approval.trendDirection || '?';
-      cache.total_feedback = String(approval.total || 0);
+    return JSON.parse(fs.readFileSync(cachePath, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function writeStatuslineCache(nextCache, cachePath = getCachePath()) {
+  fs.mkdirSync(path.dirname(cachePath), { recursive: true });
+  fs.writeFileSync(cachePath, JSON.stringify(nextCache));
+}
+
+function normalizeDashboardPayload(payload = {}) {
+  const approval = payload.approval || {};
+  return {
+    thumbs_up: String(approval.totalPositive || 0),
+    thumbs_down: String(approval.totalNegative || 0),
+    lessons: String((payload.rubric || {}).samples || 0),
+    approval_rate: String(approval.approvalRate || '?'),
+    trend: approval.trendDirection || '?',
+    total_feedback: String(approval.total || 0),
+  };
+}
+
+function normalizeStatsPayload(payload = {}) {
+  return {
+    thumbs_up: String(payload.totalPositive || 0),
+    thumbs_down: String(payload.totalNegative || 0),
+    lessons: String((payload.rubric || {}).samples || 0),
+    approval_rate: String(Math.round((payload.approvalRate || 0) * 1000) / 10),
+    trend: payload.trend || '?',
+    total_feedback: String(payload.total || 0),
+  };
+}
+
+function refreshStatuslineCache(statsPayload = {}, cachePath = getCachePath()) {
+  const cache = {
+    ...readExistingCache(cachePath),
+    ...normalizeStatsPayload(statsPayload),
+    updated_at: String(Math.floor(Date.now() / 1000)),
+  };
+  writeStatuslineCache(cache, cachePath);
+  return cache;
+}
+
+function updateCacheFromEvent(event = {}, cachePath = getCachePath()) {
+  const tool = event.tool_name || '';
+  if (tool !== 'mcp__thumbgate__feedback_stats' && tool !== 'mcp__thumbgate__dashboard') {
+    return null;
+  }
+
+  const raw = event.tool_response;
+  if (!raw) return null;
+  const data = typeof raw === 'string' ? JSON.parse(raw) : raw;
+  const cache = {
+    ...readExistingCache(cachePath),
+    ...(tool === 'mcp__thumbgate__feedback_stats'
+      ? normalizeStatsPayload(data)
+      : normalizeDashboardPayload(data)),
+    updated_at: String(Math.floor(Date.now() / 1000)),
+  };
+  writeStatuslineCache(cache, cachePath);
+  return cache;
+}
+
+function runFromStdin() {
+  let input = '';
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', (chunk) => { input += chunk; });
+  process.stdin.on('end', () => {
+    try {
+      updateCacheFromEvent(input ? JSON.parse(input) : {});
+    } catch {
+      /* statusline cache is best-effort */
     }
-    cache.updated_at = String(Math.floor(Date.now() / 1000));
+  });
+}
+
+if (require.main === module) {
+  runFromStdin();
+}
 
-    fs.mkdirSync(path.dirname(CACHE_PATH), { recursive: true });
-    fs.writeFileSync(CACHE_PATH, JSON.stringify(cache));
-  } catch (_) { /* silent — statusline cache is best-effort */ }
-});
+module.exports = {
+  getCachePath,
+  normalizeDashboardPayload,
+  normalizeStatsPayload,
+  readExistingCache,
+  refreshStatuslineCache,
+  runFromStdin,
+  updateCacheFromEvent,
+  writeStatuslineCache,
+};

package/scripts/hosted-config.js

@@ -76,6 +76,10 @@ function normalizeTrackingId(value, pattern) {
   return trimmed;
 }
 
+function resolveNormalizedOrigin(value, fallback = '') {
+  return normalizeOrigin(value) || normalizeOrigin(fallback);
+}
+
 function joinPublicUrl(baseOrigin, pathname) {
   const normalized = normalizeOrigin(baseOrigin);
   if (!normalized) {
@@ -112,16 +116,14 @@ function buildHostedCancelUrl(appOrigin, traceId) {
   return `${joinPublicUrl(appOrigin, '/cancel')}${traceQuery}`;
 }
 
-function resolveHostedBillingConfig({ requestOrigin } = {}) {
+function resolveHostedBillingConfig({ requestOrigin } = {}, env = process.env) {
   const inferredOrigin = normalizeOrigin(requestOrigin) || DEFAULT_PUBLIC_APP_ORIGIN;
-  const appOrigin = normalizeOrigin(process.env.THUMBGATE_PUBLIC_APP_ORIGIN) || inferredOrigin;
-  const billingApiBaseUrl = normalizeOrigin(
-    process.env.THUMBGATE_BILLING_API_BASE_URL || process.env.THUMBGATE_CANONICAL_API_BASE_URL || appOrigin
-  ) || appOrigin;
-  const proPriceDollars = normalizePriceDollars(process.env.THUMBGATE_PRO_PRICE_DOLLARS) || DEFAULT_PRO_PRICE_DOLLARS;
-  const proPriceLabel = process.env.THUMBGATE_PRO_PRICE_LABEL || DEFAULT_PRO_PRICE_LABEL;
-  const gaMeasurementId = normalizeTrackingId(process.env.THUMBGATE_GA_MEASUREMENT_ID, GA_MEASUREMENT_ID_PATTERN);
-  const googleSiteVerification = normalizeTrackingId(process.env.THUMBGATE_GOOGLE_SITE_VERIFICATION);
+  const appOrigin = resolveNormalizedOrigin(env.THUMBGATE_PUBLIC_APP_ORIGIN, inferredOrigin) || inferredOrigin;
+  const billingApiBaseUrl = resolveNormalizedOrigin(env.THUMBGATE_BILLING_API_BASE_URL, appOrigin) || appOrigin;
+  const proPriceDollars = normalizePriceDollars(env.THUMBGATE_PRO_PRICE_DOLLARS) || DEFAULT_PRO_PRICE_DOLLARS;
+  const proPriceLabel = env.THUMBGATE_PRO_PRICE_LABEL || DEFAULT_PRO_PRICE_LABEL;
+  const gaMeasurementId = normalizeTrackingId(env.THUMBGATE_GA_MEASUREMENT_ID, GA_MEASUREMENT_ID_PATTERN);
+  const googleSiteVerification = normalizeTrackingId(env.THUMBGATE_GOOGLE_SITE_VERIFICATION);
 
   return {
     appOrigin,
@@ -129,7 +131,7 @@ function resolveHostedBillingConfig({ requestOrigin } = {}) {
     checkoutEndpoint: joinPublicUrl(billingApiBaseUrl, '/v1/billing/checkout'),
     sessionEndpoint: joinPublicUrl(billingApiBaseUrl, '/v1/billing/session'),
     checkoutFallbackUrl: normalizeAbsoluteUrl(
-      process.env.THUMBGATE_CHECKOUT_FALLBACK_URL || DEFAULT_CHECKOUT_FALLBACK_URL
+      env.THUMBGATE_CHECKOUT_FALLBACK_URL || DEFAULT_CHECKOUT_FALLBACK_URL
     ) || DEFAULT_CHECKOUT_FALLBACK_URL,
     proPriceDollars,
     proPriceLabel,

package/scripts/hybrid-feedback-context.js

@@ -22,14 +22,24 @@ const { resolveFeedbackDir } = require('./feedback-paths');
 // Paths
 // ---------------------------------------------------------------------------
 
-const FEEDBACK_DIR = resolveFeedbackDir();
-const PATHS = {
-  feedbackLog: path.join(FEEDBACK_DIR, 'feedback-log.jsonl'),
-  inbox: path.join(FEEDBACK_DIR, 'inbox.jsonl'),
-  pendingSync: path.join(FEEDBACK_DIR, 'pending_cortex_sync.jsonl'),
-  attributedFeedback: path.join(FEEDBACK_DIR, 'attributed-feedback.jsonl'),
-  guardArtifact: path.join(FEEDBACK_DIR, 'pretool-guards.json'),
-};
+function getHybridPaths(options = {}) {
+  const feedbackDir = resolveFeedbackDir({
+    cwd: options.cwd,
+    env: options.env,
+    feedbackDir: options.feedbackDir,
+    home: options.home,
+  });
+  return {
+    feedbackDir,
+    feedbackLog: path.join(feedbackDir, 'feedback-log.jsonl'),
+    inbox: path.join(feedbackDir, 'inbox.jsonl'),
+    pendingSync: path.join(feedbackDir, 'pending_cortex_sync.jsonl'),
+    attributedFeedback: path.join(feedbackDir, 'attributed-feedback.jsonl'),
+    guardArtifact: path.join(feedbackDir, 'pretool-guards.json'),
+  };
+}
+
+const PATHS = getHybridPaths();
 
 // ---------------------------------------------------------------------------
 // Constants
@@ -192,10 +202,11 @@ function hashText(text) {
  */
 function buildHybridState(opts) {
   const o = opts || {};
-  const feedbackLogPath = o.feedbackLogPath || process.env.THUMBGATE_FEEDBACK_LOG || PATHS.feedbackLog;
-  const inboxPath = o.inboxPath || process.env.THUMBGATE_FEEDBACK_INBOX || PATHS.inbox;
-  const pendingSyncPath = o.pendingSyncPath || process.env.THUMBGATE_PENDING_SYNC || PATHS.pendingSync;
-  const attributedFeedbackPath = o.attributedFeedbackPath || process.env.THUMBGATE_ATTRIBUTED_FEEDBACK || PATHS.attributedFeedback;
+  const paths = getHybridPaths(o);
+  const feedbackLogPath = o.feedbackLogPath || process.env.THUMBGATE_FEEDBACK_LOG || paths.feedbackLog;
+  const inboxPath = o.inboxPath || process.env.THUMBGATE_FEEDBACK_INBOX || paths.inbox;
+  const pendingSyncPath = o.pendingSyncPath || process.env.THUMBGATE_PENDING_SYNC || paths.pendingSync;
+  const attributedFeedbackPath = o.attributedFeedbackPath || process.env.THUMBGATE_ATTRIBUTED_FEEDBACK || paths.attributedFeedback;
 
   const feedbackEntries = readJsonl(feedbackLogPath);
   const inboxEntries = readJsonl(inboxPath);
@@ -236,6 +247,21 @@ function buildHybridState(opts) {
         entry.context || '',
         entry.whatWentWrong || entry.what_went_wrong || '',
         entry.whatToChange || entry.what_to_change || '',
+        entry.failureType || '',
+        ...(Array.isArray(entry.tags) ? entry.tags : []),
+        ...(entry.richContext && Array.isArray(entry.richContext.filePaths) ? entry.richContext.filePaths : []),
+        ...(entry.structuredRule && entry.structuredRule.metadata && Array.isArray(entry.structuredRule.metadata.filesInvolved)
+          ? entry.structuredRule.metadata.filesInvolved
+          : []),
+        entry.structuredRule && entry.structuredRule.action ? entry.structuredRule.action.description || '' : '',
+        entry.structuredRule && entry.structuredRule.trigger ? entry.structuredRule.trigger.condition || '' : '',
+        entry.richContext && entry.richContext.enforcement
+          ? [
+            entry.richContext.enforcement.scopeViolation ? 'scope violation' : '',
+            entry.richContext.enforcement.approvalFailure ? 'approval failure' : '',
+            entry.richContext.enforcement.protectedFileViolation ? 'protected file violation' : '',
+          ].join(' ')
+          : '',
       ].join(' ');
       const norm = normalizePatternText(rawText);
       if (!norm) continue;
@@ -260,6 +286,20 @@ function buildHybridState(opts) {
     const rawText = [
       entry.context || '',
       entry.whatWentWrong || entry.what_went_wrong || '',
+      ...(Array.isArray(entry.tags) ? entry.tags : []),
+      ...(entry.richContext && Array.isArray(entry.richContext.filePaths) ? entry.richContext.filePaths : []),
+      ...(entry.structuredRule && entry.structuredRule.metadata && Array.isArray(entry.structuredRule.metadata.filesInvolved)
+        ? entry.structuredRule.metadata.filesInvolved
+        : []),
+      entry.structuredRule && entry.structuredRule.action ? entry.structuredRule.action.description || '' : '',
+      entry.structuredRule && entry.structuredRule.trigger ? entry.structuredRule.trigger.condition || '' : '',
+      entry.richContext && entry.richContext.enforcement
+        ? [
+          entry.richContext.enforcement.scopeViolation ? 'scope violation' : '',
+          entry.richContext.enforcement.approvalFailure ? 'approval failure' : '',
+          entry.richContext.enforcement.protectedFileViolation ? 'protected file violation' : '',
+        ].join(' ')
+        : '',
     ].join(' ');
     const norm = normalizePatternText(rawText);
     if (!norm) continue;
@@ -586,7 +626,7 @@ function evaluatePretool(toolName, toolInput, opts) {
   const o = opts || {};
 
   // Fast path: compiled artifact
-  const artifactPath = o.guardArtifactPath || process.env.THUMBGATE_GUARDS_PATH || PATHS.guardArtifact;
+  const artifactPath = o.guardArtifactPath || process.env.THUMBGATE_GUARDS_PATH || getHybridPaths(o).guardArtifact;
   const artifact = readGuardArtifact(artifactPath);
   if (artifact) {
     const result = evaluateCompiledGuards(artifact, toolName, toolInput);
@@ -667,6 +707,7 @@ module.exports = {
   hashText,
   hasTwoKeywordHits,
   readJsonl,
+  getHybridPaths,
   PATHS,
 };
 

package/scripts/install-mcp.js

@@ -16,7 +16,8 @@ const fs = require('fs');
 const path = require('path');
 const { resolveMcpEntry } = require('./mcp-config');
 
-const MCP_SERVER_KEY = 'rlhf';
+const MCP_SERVER_KEY = 'thumbgate';
+const LEGACY_MCP_SERVER_KEYS = ['mcp-memory-gateway', 'rlhf'];
 const PKG_ROOT = path.join(__dirname, '..');
 const PKG_VERSION = JSON.parse(fs.readFileSync(path.join(PKG_ROOT, 'package.json'), 'utf8')).version;
 
@@ -80,9 +81,15 @@ function serverConfigMatches(entry, flags = {}) {
 }
 
 function isAlreadyInstalled(settings, flags = {}) {
+  const hasLegacyAliases = Boolean(
+    settings &&
+    settings.mcpServers &&
+    LEGACY_MCP_SERVER_KEYS.some((key) => Object.prototype.hasOwnProperty.call(settings.mcpServers, key))
+  );
   return !!(
     settings &&
     settings.mcpServers &&
+    !hasLegacyAliases &&
     serverConfigMatches(settings.mcpServers[MCP_SERVER_KEY], flags)
   );
 }
@@ -120,6 +127,11 @@ function installMcp(flags) {
   }
 
   settings.mcpServers[MCP_SERVER_KEY] = serverConfig;
+  for (const legacyKey of LEGACY_MCP_SERVER_KEYS) {
+    if (Object.prototype.hasOwnProperty.call(settings.mcpServers, legacyKey)) {
+      delete settings.mcpServers[legacyKey];
+    }
+  }
 
   // Ensure parent directory exists
   const dir = path.dirname(settingsPath);
@@ -142,6 +154,7 @@ function installMcp(flags) {
 // Exported for testing
 module.exports = {
   MCP_SERVER_KEY,
+  LEGACY_MCP_SERVER_KEYS,
   MCP_SERVER_CONFIG,
   resolveMcpServerConfig,
   resolveSettingsPath,

package/scripts/intent-router.js

@@ -265,7 +265,7 @@ const ACTION_CATEGORY_MAP = {
   feedback_summary: 'debugging',
   search_lessons: 'search',
   retrieve_lessons: 'search',
-  search_rlhf: 'search',
+  search_thumbgate: 'search',
   prevention_rules: 'security',
   construct_context_pack: 'architecture',
   export_dpo_pairs: 'testing',

package/scripts/internal-agent-bootstrap.js

@@ -17,7 +17,7 @@ const { formatCodeGraphRecallSection } = require('./codegraph-context');
 
 const KNOWN_SOURCES = new Set(['github', 'slack', 'linear', 'api', 'cli']);
 const DEFAULT_SOURCE = 'api';
-const DEFAULT_SANDBOX_ROOT = path.join(os.tmpdir(), 'rlhf-internal-agent-sandboxes');
+const DEFAULT_SANDBOX_ROOT = path.join(os.tmpdir(), 'thumbgate-internal-agent-sandboxes');
 
 function normalizeText(value) {
   if (value === undefined || value === null) return '';

package/scripts/lesson-inference.js

@@ -31,6 +31,11 @@ function getFeedbackDir() {
   return resolveFeedbackDir();
 }
 
+function getLessonBaseUrl() {
+  const configuredOrigin = String(process.env.THUMBGATE_PUBLIC_APP_ORIGIN || '').trim().replace(/\/+$/, '');
+  return configuredOrigin || 'http://localhost:3456';
+}
+
 function getLessonsPath() { return path.join(getFeedbackDir(), LESSONS_FILE); }
 function getRecentLessonPath() { return path.join(getFeedbackDir(), RECENT_LESSON_FILE); }
 
@@ -138,7 +143,7 @@ function createLesson({ feedbackId, signal, inferredLesson, triggerMessage, prio
   };
 
   // Stable link: dashboard deep-link to this lesson
-  lesson.link = `http://localhost:9876/lessons#${lesson.id}`;
+  lesson.link = `${getLessonBaseUrl()}/lessons#${lesson.id}`;
 
   const lessonsPath = getLessonsPath();
   ensureDir(lessonsPath);