thumbgate 0.9.10 → 0.9.12

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-auto-capture.sh

@@ -7,8 +7,13 @@ PROMPT="$CLAUDE_USER_PROMPT"
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
 CAPTURE="$SCRIPT_DIR/../.claude/scripts/feedback/capture-feedback.js"
 PROMPT_GUARD="$SCRIPT_DIR/prompt-guard.js"
-FEEDBACK_LOG="$SCRIPT_DIR/../.claude/memory/feedback/feedback-log.jsonl"
-MEMORY_LOG="$SCRIPT_DIR/../.claude/memory/feedback/memory-log.jsonl"
+ACTIVE_CWD="${CLAUDE_PROJECT_DIR:-${PWD:-$(pwd)}}"
+FEEDBACK_DIR="$(node -e "const path = require('path'); const { resolveFeedbackDir } = require(path.join(process.argv[1], 'feedback-paths.js')); process.stdout.write(resolveFeedbackDir({ cwd: process.argv[2] || process.cwd(), feedbackDir: process.env.THUMBGATE_FEEDBACK_DIR || undefined }));" "$SCRIPT_DIR" "$ACTIVE_CWD" 2>/dev/null)"
+if [ -z "$FEEDBACK_DIR" ]; then
+  FEEDBACK_DIR="${THUMBGATE_FEEDBACK_DIR:-$ACTIVE_CWD/.rlhf}"
+fi
+FEEDBACK_LOG="$FEEDBACK_DIR/feedback-log.jsonl"
+MEMORY_LOG="$FEEDBACK_DIR/memory-log.jsonl"
 
 # Record the latest user prompt so statusline thumbs can distill lessons
 # from recent conversation even when the click itself has no body payload.
@@ -49,7 +54,7 @@ capture_and_report() {
   echo "Storage Proof:"
   echo "  Feedback log : $FEEDBACK_LOG ($(wc -l < "$FEEDBACK_LOG" 2>/dev/null || echo 0) entries)"
   echo "  Memory log   : $MEMORY_LOG ($(wc -l < "$MEMORY_LOG" 2>/dev/null || echo 0) entries)"
-  echo "  LanceDB      : $SCRIPT_DIR/../.claude/memory/feedback/lancedb/"
+  echo "  LanceDB      : $FEEDBACK_DIR/lancedb/"
   echo ""
 
   # Show last entry written

package/scripts/hook-runtime.js

@@ -0,0 +1,81 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const {
+  isSourceCheckout,
+  publishedCliAvailable,
+} = require('./mcp-config');
+const { publishedCliShellCommand } = 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);
+  }
+
+  const available = true;
+  featureSupportCache.set(version, available);
+  return available;
+}
+
+function resolveCliBaseCommand() {
+  const version = packageVersion();
+  if (publishedHookCommandsAvailable(version)) {
+    return publishedCliShellCommand(version);
+  }
+  if (isSourceCheckout(PKG_ROOT)) {
+    return `node ${shellQuote(path.join(PKG_ROOT, 'bin', 'cli.js'))}`;
+  }
+  return publishedCliShellCommand(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_DIR = process.env.THUMBGATE_FEEDBACK_DIR || process.cwd();
-const CACHE_PATH = path.join(CACHE_DIR, '.thumbgate', '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__thumbgate__feedback_stats' && tool !== 'mcp__thumbgate__dashboard') return;
-
-    const raw = event.tool_response;
-    if (!raw) return;
-    const data = typeof raw === 'string' ? JSON.parse(raw) : raw;
-
-    const cache = {};
-    if (tool === 'mcp__thumbgate__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__thumbgate__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

@@ -12,12 +12,6 @@ const DEFAULT_CHECKOUT_FALLBACK_URL = PRO_MONTHLY_PAYMENT_LINK;
 const DEFAULT_PRO_PRICE_DOLLARS = PRO_MONTHLY_PRICE_DOLLARS;
 const DEFAULT_PRO_PRICE_LABEL = PRO_PRICE_LABEL;
 const GA_MEASUREMENT_ID_PATTERN = /^G-[A-Z0-9]+$/i;
-const PUBLIC_APP_ORIGIN_KEYS = ['THUMBGATE_PUBLIC_APP_ORIGIN', 'RLHF_PUBLIC_APP_ORIGIN'];
-const BILLING_API_BASE_URL_KEYS = [
-  'THUMBGATE_BILLING_API_BASE_URL',
-  'RLHF_BILLING_API_BASE_URL',
-  'THUMBGATE_CANONICAL_API_BASE_URL',
-];
 
 function normalizeOrigin(value) {
   if (!value || typeof value !== 'string') {
@@ -82,14 +76,8 @@ function normalizeTrackingId(value, pattern) {
   return trimmed;
 }
 
-function resolveNormalizedOrigin(env, keys, fallback = '') {
-  for (const key of keys) {
-    const normalized = normalizeOrigin(env[key]);
-    if (normalized) {
-      return normalized;
-    }
-  }
-  return normalizeOrigin(fallback);
+function resolveNormalizedOrigin(value, fallback = '') {
+  return normalizeOrigin(value) || normalizeOrigin(fallback);
 }
 
 function joinPublicUrl(baseOrigin, pathname) {
@@ -130,8 +118,8 @@ function buildHostedCancelUrl(appOrigin, traceId) {
 
 function resolveHostedBillingConfig({ requestOrigin } = {}, env = process.env) {
   const inferredOrigin = normalizeOrigin(requestOrigin) || DEFAULT_PUBLIC_APP_ORIGIN;
-  const appOrigin = resolveNormalizedOrigin(env, PUBLIC_APP_ORIGIN_KEYS, inferredOrigin) || inferredOrigin;
-  const billingApiBaseUrl = resolveNormalizedOrigin(env, BILLING_API_BASE_URL_KEYS, appOrigin) || appOrigin;
+  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);

package/scripts/hybrid-feedback-context.js

@@ -16,21 +16,30 @@
 
 const fs = require('fs');
 const path = require('path');
-const os = require('os');
+const { resolveFeedbackDir } = require('./feedback-paths');
 
 // ---------------------------------------------------------------------------
 // Paths
 // ---------------------------------------------------------------------------
 
-const ROOT = path.join(__dirname, '..');
+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 = {
-  feedbackLog: path.join(ROOT, '.claude', 'memory', 'feedback', 'feedback-log.jsonl'),
-  inbox: path.join(ROOT, '.claude', 'memory', 'feedback', 'inbox.jsonl'),
-  pendingSync: path.join(ROOT, '.claude', 'memory', 'feedback', 'pending_cortex_sync.jsonl'),
-  attributedFeedback: path.join(ROOT, '.claude', 'memory', 'feedback', 'attributed-feedback.jsonl'),
-  guardArtifact: path.join(ROOT, '.claude', 'memory', 'feedback', 'pretool-guards.json'),
-};
+const PATHS = getHybridPaths();
 
 // ---------------------------------------------------------------------------
 // Constants
@@ -193,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);
@@ -237,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;
@@ -261,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;
@@ -587,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);
@@ -668,6 +707,7 @@ module.exports = {
   hashText,
   hasTwoKeywordHits,
   readJsonl,
+  getHybridPaths,
   PATHS,
 };
 

package/scripts/install-mcp.js

@@ -17,6 +17,7 @@ const path = require('path');
 const { resolveMcpEntry } = require('./mcp-config');
 
 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;
 
@@ -29,8 +30,6 @@ function resolveMcpServerConfig(flags = {}) {
   });
 }
 
-const MCP_SERVER_CONFIG = resolveMcpServerConfig();
-
 function parseFlags(argv) {
   const flags = {};
   for (const arg of argv) {
@@ -80,9 +79,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 +125,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,7 +152,7 @@ function installMcp(flags) {
 // Exported for testing
 module.exports = {
   MCP_SERVER_KEY,
-  MCP_SERVER_CONFIG,
+  LEGACY_MCP_SERVER_KEYS,
   resolveMcpServerConfig,
   resolveSettingsPath,
   loadSettings,

package/scripts/intent-router.js

@@ -13,6 +13,7 @@ const {
   evaluateDelegation,
   normalizeDelegationMode,
 } = require('./delegation-runtime');
+const { resolveFeedbackDir } = require('./feedback-paths');
 
 const PROJECT_ROOT = path.join(__dirname, '..');
 const DEFAULT_BUNDLE_DIR = path.join(PROJECT_ROOT, 'config', 'policy-bundles');
@@ -274,8 +275,7 @@ const ACTION_CATEGORY_MAP = {
 };
 
 function getDefaultModelPath() {
-  const feedbackDir = process.env.THUMBGATE_FEEDBACK_DIR
-    || path.join(PROJECT_ROOT, '.claude', 'memory', 'feedback');
+  const feedbackDir = resolveFeedbackDir();
   return path.join(feedbackDir, 'feedback_model.json');
 }
 

package/scripts/license.js

@@ -3,42 +3,71 @@ const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
 
-const LICENSE_PATH = path.join(process.env.HOME || process.env.USERPROFILE || '.', '.thumbgate', 'license.json');
 const VALID_PREFIXES = ['tg_pro_', 'tg_'];
+const LEGACY_COMPATIBLE_KEY = /^[a-z]{4,16}_[a-f0-9]{24,}$/i;
+
+function getLicensePath(homeDir = process.env.HOME || process.env.USERPROFILE || '.') {
+  return path.join(homeDir, '.thumbgate', 'license.json');
+}
+
+const LICENSE_PATH = getLicensePath();
 
 function isValidKey(key) {
-  return key && VALID_PREFIXES.some((p) => key.startsWith(p));
+  return Boolean(
+    key
+    && (
+      VALID_PREFIXES.some((p) => key.startsWith(p))
+      || LEGACY_COMPATIBLE_KEY.test(key)
+    )
+  );
 }
 
-function verifyLicense() {
-  const envKey = process.env.THUMBGATE_API_KEY || process.env.THUMBGATE_PRO_KEY;
+function verifyLicense(options = {}) {
+  const envKey = [
+    process.env.THUMBGATE_API_KEY,
+    process.env.THUMBGATE_PRO_KEY,
+    ...Object.entries(process.env)
+      .filter(([name]) => /(?:_API_KEY|_PRO_KEY)$/.test(name))
+      .map(([, value]) => value),
+  ].find((value) => isValidKey(value));
   if (isValidKey(envKey)) {
     return { valid: true, source: 'env', key: envKey };
   }
+
+  const licensePath = getLicensePath(options.homeDir);
   try {
-    if (fs.existsSync(LICENSE_PATH)) {
-      const data = JSON.parse(fs.readFileSync(LICENSE_PATH, 'utf8'));
+    if (fs.existsSync(licensePath)) {
+      const data = JSON.parse(fs.readFileSync(licensePath, 'utf8'));
       if (isValidKey(data.key)) {
-        return { valid: true, source: 'file', key: data.key, activatedAt: data.activatedAt };
+        return {
+          valid: true,
+          source: 'file',
+          key: data.key,
+          activatedAt: data.activatedAt,
+          path: licensePath,
+        };
       }
     }
   } catch (_) {}
+
   return { valid: false, source: null };
 }
 
-function isProLicensed() {
-  return verifyLicense().valid;
+function isProLicensed(options) {
+  return verifyLicense(options).valid;
 }
 
-function activateLicense(key) {
+function activateLicense(key, options = {}) {
   if (!isValidKey(key)) {
     return { success: false, error: 'Invalid key format. Expected tg_... or tg_pro_...' };
   }
-  const dir = path.dirname(LICENSE_PATH);
+
+  const licensePath = getLicensePath(options.homeDir);
+  const dir = path.dirname(licensePath);
   if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
   const data = { key, activatedAt: new Date().toISOString(), version: require('../package.json').version };
-  fs.writeFileSync(LICENSE_PATH, JSON.stringify(data, null, 2));
-  return { success: true, path: LICENSE_PATH };
+  fs.writeFileSync(licensePath, JSON.stringify(data, null, 2));
+  return { success: true, path: licensePath };
 }
 
 function generateLicenseKey(email) {
@@ -47,4 +76,13 @@ function generateLicenseKey(email) {
   return `tg_pro_${hash}`;
 }
 
-module.exports = { verifyLicense, isProLicensed, activateLicense, generateLicenseKey, isValidKey, VALID_PREFIXES, LICENSE_PATH };
+module.exports = {
+  verifyLicense,
+  isProLicensed,
+  activateLicense,
+  generateLicenseKey,
+  isValidKey,
+  VALID_PREFIXES,
+  LICENSE_PATH,
+  getLicensePath,
+};

package/scripts/local-model-profile.js

@@ -4,9 +4,10 @@
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
+const { resolveFeedbackDir: resolveSharedFeedbackDir } = require('./feedback-paths');
 
 const PROJECT_ROOT = path.join(__dirname, '..');
-const DEFAULT_FEEDBACK_DIR = path.join(PROJECT_ROOT, '.claude', 'memory', 'feedback');
+const DEFAULT_FEEDBACK_DIR = resolveSharedFeedbackDir();
 const DEFAULT_EMBED_MODEL = 'Xenova/all-MiniLM-L6-v2';
 
 // ---------------------------------------------------------------------------
@@ -232,7 +233,7 @@ function recommendInferenceBackend(task = {}, env = process.env) {
 }
 
 function resolveFeedbackDir(explicitDir) {
-  return explicitDir || process.env.THUMBGATE_FEEDBACK_DIR || DEFAULT_FEEDBACK_DIR;
+  return resolveSharedFeedbackDir({ feedbackDir: explicitDir });
 }
 
 function detectHardware(env = process.env) {