thumbgate 1.27.18 → 1.27.20

package/bin/cli.js

@@ -23,14 +23,18 @@
  *   npx thumbgate background-governance  # background-agent run report + risk check
  *   npx thumbgate cfo           # local operational billing summary
  *   npx thumbgate pro           # solo dashboard + exports side lane
+ *   npx thumbgate diagnostic    # team workflow diagnostic intake + checkout path
+ *   npx thumbgate audit <file>  # audit an agent transcript for repeat-mistake token waste
  */
 
 'use strict';
 
 const fs = require('fs');
+const os = require('os');
 const path = require('path');
 const crypto = require('crypto');
-const { execSync, execFileSync } = require('child_process');
+const http = require('http');
+const { execSync, execFileSync, execFile, spawn } = require('child_process');
 const {
   codexAutoUpdateCliEntry,
   codexAutoUpdateMcpEntry,
@@ -40,13 +44,6 @@ const {
   resolveMcpEntry,
 } = require(path.join(__dirname, '..', 'scripts', 'mcp-config'));
 const { trackEvent } = require(path.join(__dirname, '..', 'scripts', 'cli-telemetry'));
-const {
-  cacheUpdateHookCommand,
-  preToolHookCommand,
-  sessionStartHookCommand,
-  statuslineCommand,
-  userPromptHookCommand,
-} = require(path.join(__dirname, '..', 'scripts', 'hook-runtime'));
 const {
   PRO_MONTHLY_PAYMENT_LINK,
   PRO_PRICE_LABEL,
@@ -56,8 +53,74 @@ const COMMAND = process.argv[2];
 const CWD = process.cwd();
 const PKG_ROOT = path.join(__dirname, '..');
 
-const PRO_URL = 'https://thumbgate-production.up.railway.app';
+const PRO_URL = 'https://thumbgate.ai';
 const PRO_CHECKOUT_URL = PRO_MONTHLY_PAYMENT_LINK;
+// Mirrors scripts/rate-limiter.js TRIAL_DAYS — must stay in sync. Gitar
+// caught a 14-vs-7 mismatch on PR #2337 (banner said "7-day trial" but
+// the date label was computed 14 days out).
+const TRIAL_DAYS = 7;
+
+function checkoutUrlFor(source, content) {
+  try {
+    const base = content === 'capture_feedback'
+      ? 'https://buy.stripe.com/7sYfZhaiE1eSbO99uj3sI0d'
+      : PRO_CHECKOUT_URL;
+    const url = new URL(base);
+    url.searchParams.set('utm_source', source || 'cli');
+    url.searchParams.set('utm_medium', 'cli');
+    url.searchParams.set('utm_campaign', 'pro_conversion');
+    if (content) url.searchParams.set('utm_content', content);
+    return url.toString();
+  } catch (_) {
+    return content === 'capture_feedback'
+      ? 'https://buy.stripe.com/7sYfZhaiE1eSbO99uj3sI0d'
+      : PRO_CHECKOUT_URL;
+  }
+}
+
+function pricingUrlFor(source, content) {
+  try {
+    const url = new URL('/pricing', PRO_URL);
+    url.searchParams.set('utm_source', source || 'cli');
+    url.searchParams.set('utm_medium', 'cli');
+    url.searchParams.set('utm_campaign', 'pro_education');
+    if (content) url.searchParams.set('utm_content', content);
+    return url.toString();
+  } catch (_) {
+    return `${PRO_URL}/pricing`;
+  }
+}
+
+function diagnosticUrlFor(source, content) {
+  try {
+    const url = new URL('/diagnostic', PRO_URL);
+    url.searchParams.set('utm_source', source || 'cli');
+    url.searchParams.set('utm_medium', 'cli');
+    url.searchParams.set('utm_campaign', 'workflow_hardening_diagnostic');
+    if (content) url.searchParams.set('utm_content', content);
+    return url.toString();
+  } catch (_) {
+    return `${PRO_URL}/diagnostic`;
+  }
+}
+
+function diagnosticCheckoutUrlFor(source, content) {
+  try {
+    const url = new URL('/go/diagnostic', PRO_URL);
+    url.searchParams.set('utm_source', source || 'cli');
+    url.searchParams.set('utm_medium', 'cli');
+    url.searchParams.set('utm_campaign', 'workflow_hardening_diagnostic');
+    if (content) url.searchParams.set('utm_content', content);
+    return url.toString();
+  } catch (_) {
+    return `${PRO_URL}/go/diagnostic`;
+  }
+}
+
+function trialDeadlineLabel(now = new Date()) {
+  const deadline = new Date(now.getTime() + (TRIAL_DAYS * 24 * 60 * 60 * 1000));
+  return deadline.toISOString().slice(0, 10);
+}
 
 function upgradeNudge() {
   if (process.env.THUMBGATE_NO_NUDGE === '1') return;
@@ -65,14 +128,37 @@ function upgradeNudge() {
     const { isProTier } = require(path.join(PKG_ROOT, 'scripts', 'rate-limiter'));
     if (isProTier()) return;
   } catch (_) { return; }
+  const pricingUrl = pricingUrlFor('cli_upgrade_nudge', COMMAND || 'general');
+  const diagnosticUrl = diagnosticUrlFor('cli_upgrade_nudge', COMMAND || 'general');
   process.stderr.write(
-    '\n  Team rollout: start with the Workflow Hardening Sprint\n' +
-    '  https://thumbgate-production.up.railway.app/#workflow-sprint-intake\n' +
+    '\n  Team rollout: start with the $499 Workflow Hardening Diagnostic\n' +
+    `  ${diagnosticUrl}\n` +
     `\n  Solo side lane: Pro — ${PRO_PRICE_LABEL}\n` +
-    `  ${PRO_CHECKOUT_URL}\n\n`
+    '  Keeps lessons, rules, and the dashboard synced across machines and agent runtimes.\n' +
+    `  ${pricingUrl}\n\n`
   );
 }
 
+function diagnostic() {
+  const intakeUrl = diagnosticUrlFor('cli_diagnostic', COMMAND || 'diagnostic');
+  const checkoutUrl = diagnosticCheckoutUrlFor('cli_diagnostic', COMMAND || 'diagnostic');
+  console.log('');
+  console.log('  ThumbGate Workflow Hardening Diagnostic');
+  console.log('  ---------------------------------------');
+  console.log('  Use this when one repeated AI-agent workflow failure is already costing');
+  console.log('  review time, release confidence, customer trust, or money.');
+  console.log('');
+  console.log('  Best fit: one workflow, one repeated failure, one owner who can review proof.');
+  console.log('  Output: failure taxonomy, block/warn/human-review split, and proof checklist.');
+  console.log('');
+  console.log('  Start with intake:');
+  console.log(`  ${intakeUrl}`);
+  console.log('');
+  console.log('  Ready to pay now:');
+  console.log(`  ${checkoutUrl}`);
+  console.log('');
+}
+
 function appendLocalTelemetry(payload) {
   try {
     const { getFeedbackPaths } = require(path.join(PKG_ROOT, 'scripts', 'feedback-loop'));
@@ -126,7 +212,7 @@ function telemetryPing(installId) {
     timestamp: new Date().toISOString(),
   };
   appendLocalTelemetry(payloadObject);
-  const apiUrl = process.env.THUMBGATE_API_URL || 'https://thumbgate-production.up.railway.app';
+  const apiUrl = process.env.THUMBGATE_API_URL || 'https://thumbgate.ai';
   const payload = JSON.stringify(payloadObject);
   try {
     const url = new URL('/v1/telemetry/ping', apiUrl);
@@ -145,25 +231,47 @@ function proNudge(context) {
     const { isProTier } = require(path.join(PKG_ROOT, 'scripts', 'rate-limiter'));
     if (isProTier()) return;
   } catch (_) { /* if rate-limiter is unavailable, fall through and nudge */ }
+  const checkoutUrl = checkoutUrlFor('cli_nudge', context || COMMAND || 'general');
+  const pricingUrl = pricingUrlFor('cli_nudge', context || COMMAND || 'general');
   const messages = [
-    `\n  💡 Unlock Pro (${PRO_PRICE_LABEL}): searchable dashboard, DPO export, multi-repo sync\n     ${PRO_CHECKOUT_URL}\n`,
-    `\n  💡 Pro tip: export your feedback as DPO training pairs to improve your models.\n     Get Pro: ${PRO_CHECKOUT_URL}\n`,
-    `\n  💡 ThumbGate Pro: search, edit, and sync lessons across repos. ${PRO_PRICE_LABEL}.\n     ${PRO_CHECKOUT_URL}\n`,
+    `\n  💡 Pro (${PRO_PRICE_LABEL}): keep lessons, rules, and dashboard state synced across machines and agent runtimes.\n     See pricing: ${pricingUrl}\n`,
+    `\n  💡 You just taught ThumbGate something locally. Pro keeps that lesson alive on every laptop, CI box, and agent runtime.\n     See pricing: ${pricingUrl}\n`,
+    `\n  💡 ThumbGate Pro syncs lessons/rules across Claude, Codex, Cursor, containers, and CI. ${PRO_PRICE_LABEL}.\n     Start Pro: ${checkoutUrl}\n`,
   ];
   // Rotate message daily — no Math.random (security policy)
   const msg = messages[Math.floor(Date.now() / 86400000) % messages.length];
   process.stderr.write(msg);
 }
 
-function limitNudge(action) {
+function limitNudge(action, limitResult = {}) {
   if (process.env.THUMBGATE_NO_NUDGE === '1') return;
+  const checkoutUrl = checkoutUrlFor('cli_limit', action);
+  const usageLine = Number.isFinite(limitResult.used) && Number.isFinite(limitResult.limit)
+    ? `     Usage: ${limitResult.used}/${limitResult.limit} (${limitResult.limitType || 'limit'}).\n`
+    : '';
+  const reason = limitResult.message
+    ? String(limitResult.message).split('\n')[0]
+    : 'Free tier limit reached.';
   process.stderr.write(
-    `\n  ⚠️  Free tier limit reached. Upgrade to Pro for unlimited: https://thumbgate-production.up.railway.app/pro\n` +
-    `     ${action} daily limit reached. Upgrade to Pro for unlimited usage — ${PRO_PRICE_LABEL}:\n` +
-    `     ${PRO_CHECKOUT_URL}\n\n`
+    `\n  🔒 ${reason}\n` +
+    usageLine +
+    `     Upgrade to Pro (${PRO_PRICE_LABEL}) to continue ${action.replace(/_/g, ' ')}:\n` +
+    `     ${checkoutUrl}\n\n`
   );
 }
 
+function printInitConversionPrompt(email) {
+  if (process.env.THUMBGATE_NO_NUDGE === '1') return;
+  const checkoutUrl = checkoutUrlFor('cli_init', email ? 'init_email' : 'init_no_email');
+  console.log('');
+  console.log('  ┌──────────────────────────────────────────────────────────┐');
+  console.log(`  │  7-day Pro trial active through ${trialDeadlineLabel()}.               │`);
+  console.log('  │  Pro keeps lessons/rules/dashboard synced everywhere.   │');
+  console.log('  │  Add onboarding: npx thumbgate init --email you@company.com │');
+  console.log(`  │  Upgrade: ${checkoutUrl}`);
+  console.log('  └──────────────────────────────────────────────────────────┘');
+}
+
 function parseArgs(argv) {
   const args = {};
   argv.forEach((arg, index) => {
@@ -185,6 +293,73 @@ function parseArgs(argv) {
   return args;
 }
 
+function probeDash(port) {
+  return new Promise((resolve) => {
+    const req = http.get({ hostname: '127.0.0.1', port, path: '/health', timeout: 750 }, (res) => {
+      res.resume();
+      resolve(res.statusCode >= 200 && res.statusCode < 500);
+    });
+    req.on('error', () => resolve(false));
+    req.on('timeout', () => { req.destroy(); resolve(false); });
+  });
+}
+
+async function waitDash(port, timeoutMs = 8000) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (await probeDash(port)) return true;
+    await new Promise((r) => setTimeout(r, 250));
+  }
+  return false;
+}
+
+async function ensureDash(port) {
+  if (await probeDash(port)) {
+    return { started: false, pid: null };
+  }
+
+  const serverPath = path.join(PKG_ROOT, 'src', 'api', 'server.js');
+  const child = spawn(process.execPath, [serverPath], {
+    cwd: PKG_ROOT,
+    detached: true,
+    env: { ...process.env, PORT: String(port), THUMBGATE_ALLOW_INSECURE: process.env.THUMBGATE_ALLOW_INSECURE || 'true' },
+    stdio: 'ignore',
+  });
+  child.unref();
+
+  if (!(await waitDash(port))) {
+    throw new Error('Dashboard API timeout');
+  }
+
+  return { started: true, pid: child.pid };
+}
+
+function openBrowser(url) {
+  if (process.env.THUMBGATE_DASHBOARD_NO_OPEN === '1') {
+    console.log(`Ready: ${url}`);
+    return Promise.resolve();
+  }
+  const [command, args] = ({ darwin: ['open', [url]], win32: ['cmd', ['/c', 'start', '', url]] }[process.platform] || ['xdg-open', [url]]);
+  return new Promise((resolve, reject) => {
+    execFile(command, args, (err) => (err ? reject(err) : resolve()));
+  });
+}
+
+function parseTtlMs(value, fallbackMs = 5 * 60 * 1000) {
+  if (value === undefined || value === null || value === true || value === '') return fallbackMs;
+  const raw = String(value).trim().toLowerCase();
+  const match = raw.match(/^(\d+(?:\.\d+)?)(ms|s|m|h)?$/);
+  if (!match) return fallbackMs;
+  const amount = Number(match[1]);
+  if (!Number.isFinite(amount) || amount <= 0) return fallbackMs;
+  const unit = match[2] || 'ms';
+  const factor = unit === 'h' ? 60 * 60 * 1000
+    : unit === 'm' ? 60 * 1000
+      : unit === 's' ? 1000
+        : 1;
+  return Math.round(amount * factor);
+}
+
 function readStdinText() {
   try {
     return fs.readFileSync(0, 'utf8');
@@ -395,64 +570,24 @@ function whichExists(cmd) {
 
 function setupClaude() {
   const mcpChanged = mergeMcpJson(path.join(CWD, '.mcp.json'), 'Claude Code', 'project');
+  const { wireHooks } = require(path.join(PKG_ROOT, 'scripts', 'auto-wire-hooks'));
+  const hookResult = wireHooks({ agent: 'claude-code' });
 
-  // Upsert Stop hook into .claude/settings.json for autonomous self-scoring
-  const settingsPath = path.join(CWD, '.claude', 'settings.json');
-  const stopHookCommand = 'bash scripts/hook-stop-self-score.sh';
-
-  let settings = { hooks: {} };
-  if (fs.existsSync(settingsPath)) {
-    try { settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8')); } catch (_) { /* fresh */ }
-  }
-  settings.hooks = settings.hooks || {};
-
-  const stopAlreadyPresent = (settings.hooks.Stop || [])
-    .some(entry => (entry.hooks || []).some(h => h.command === stopHookCommand));
-
-  let hooksChanged = false;
-  if (!stopAlreadyPresent) {
-    settings.hooks.Stop = settings.hooks.Stop || [];
-    settings.hooks.Stop.push({ hooks: [{ type: 'command', command: stopHookCommand }] });
-    hooksChanged = true;
-    console.log('  Claude Code: installed Stop hook');
+  if (hookResult.error) {
+    console.log(`  Claude Code hooks: ${hookResult.error}`);
+    return mcpChanged;
   }
 
-  // Upsert PostToolUse hook for ThumbGate statusline cache updates
-  const cacheHookCommand = cacheUpdateHookCommand();
-  const originalPostToolUseCount = (settings.hooks.PostToolUse || []).length;
-  settings.hooks.PostToolUse = (settings.hooks.PostToolUse || []).filter(
-    (entry) => !(entry.hooks || []).some((h) => h.command && h.command !== cacheHookCommand && /(hook-thumbgate-cache-updater|cache-update\b)/.test(h.command))
-  );
-  if (settings.hooks.PostToolUse.length !== originalPostToolUseCount) {
-    hooksChanged = true;
-  }
-  const cacheAlreadyPresent = (settings.hooks.PostToolUse || [])
-    .some(entry => (entry.hooks || []).some(h => h.command === cacheHookCommand || (h.command && h.command.includes('cache-update'))));
-
-  if (!cacheAlreadyPresent) {
-    settings.hooks.PostToolUse = settings.hooks.PostToolUse || [];
-    settings.hooks.PostToolUse.push({
-      matcher: 'mcp__thumbgate__feedback_stats|mcp__thumbgate__dashboard',
-      hooks: [{ type: 'command', command: cacheHookCommand }]
-    });
-    hooksChanged = true;
-    console.log('  Claude Code: installed ThumbGate cache updater hook');
-  }
-
-  // Upsert statusLine for ThumbGate feedback display
-  const statuslineScript = statuslineCommand();
-  if (!settings.statusLine || settings.statusLine.command !== statuslineScript) {
-    settings.statusLine = { type: 'command', command: statuslineScript };
-    hooksChanged = true;
-    console.log('  Claude Code: installed ThumbGate status line');
-  }
-
-  if (hooksChanged) {
-    fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
-    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+  if (!hookResult.changed) {
+    console.log(`  Claude Code hooks: already configured at ${hookResult.settingsPath}`);
+  } else {
+    for (const h of hookResult.added) {
+      console.log(`  Claude Code: wired ${h.lifecycle} hook`);
+    }
+    console.log(`  Claude Code settings: ${hookResult.settingsPath}`);
   }
 
-  return mcpChanged || hooksChanged;
+  return mcpChanged || hookResult.changed;
 }
 
 function setupCodex() {
@@ -483,6 +618,20 @@ function setupCodex() {
 }
 
 function setupGemini() {
+  // Try to import custom commands as a Gemini plugin if the CLI is installed
+  const { execSync } = require('child_process');
+  let pluginImported = false;
+  for (const binName of ['agy', 'gemini']) {
+    try {
+      execSync(`${binName} plugin import "${PKG_ROOT}" --force`, { stdio: 'ignore' });
+      console.log(`  Gemini: imported thumbgate plugin via ${binName}`);
+      pluginImported = true;
+      break;
+    } catch (err) {
+      // ignore errors if command doesn't exist or fails
+    }
+  }
+
   const settingsPath = path.join(HOME, '.gemini', 'settings.json');
   if (fs.existsSync(settingsPath)) {
     const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
@@ -503,13 +652,14 @@ function setupGemini() {
       }
     }
 
-    if (!changed) return false;
+    if (!changed) return pluginImported;
     fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
     console.log('  Gemini: updated ~/.gemini/settings.json');
     return true;
   }
   // Fallback: project-level .gemini/settings.json
-  return mergeMcpJson(path.join(CWD, '.gemini', 'settings.json'), 'Gemini', 'project');
+  const mcpChanged = mergeMcpJson(path.join(CWD, '.gemini', 'settings.json'), 'Gemini', 'project');
+  return pluginImported || mcpChanged;
 }
 
 function setupAmp() {
@@ -597,6 +747,104 @@ function detectAgent(projectDir) {
   return null;
 }
 
+async function setupVertex(options = {}) {
+  const { execSync } = require('child_process');
+  const dryRun = options.dryRun === true || options['dry-run'] === true;
+  console.log(`\nthumbgate setup-vertex v${pkgVersion()}`);
+  console.log('  Zero-friction Google Cloud & Vertex AI onboarding...');
+  if (dryRun) {
+    console.log('  Dry run: will detect gcloud account/project, but will not enable services or write .env.');
+  }
+  console.log('');
+
+  // 1. Detect gcloud CLI
+  let activeAccount = '';
+  let activeProject = '';
+  try {
+    activeAccount = execSync('gcloud config get-value account', { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
+    activeProject = execSync('gcloud config get-value project', { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
+  } catch (_) {
+    console.log('  ⚠️  Google Cloud SDK (gcloud CLI) not detected or not logged in.');
+    console.log('      To automate setup, install the Google Cloud CLI and run: gcloud auth login');
+    console.log('      Otherwise, manually set the following variables in your .env file:');
+    console.log('      THUMBGATE_PROVIDER_MODE=vertex');
+    console.log('      VERTEX_PROJECT_ID=<your-gcp-project-id>');
+    console.log('');
+    return;
+  }
+
+  if (!activeAccount) {
+    console.log('  ⚠️  No active Google Cloud account set. Run: gcloud auth login');
+    return;
+  }
+
+  console.log(`  Active Account : \x1b[36m${activeAccount}\x1b[0m`);
+  if (!activeProject) {
+    console.log('  ⚠️  No active Google Cloud project set. Run: gcloud config set project <PROJECT_ID>');
+    return;
+  }
+  console.log(`  Active Project : \x1b[36m${activeProject}\x1b[0m`);
+
+  // Validate project ID matches GCP format before use in shell
+  if (!/^[a-z][a-z0-9-]{4,28}[a-z0-9]$/.test(activeProject)) {
+    console.log('  ⚠️  Invalid GCP project ID format. Aborting.');
+    return;
+  }
+
+  if (dryRun) {
+    console.log(`  DRY-RUN would enable Vertex AI API for project: ${activeProject}`);
+    console.log(`  DRY-RUN would write THUMBGATE_PROVIDER_MODE=vertex and VERTEX_PROJECT_ID=${activeProject} to .env.`);
+    console.log('');
+    console.log('  Dry run complete. Re-run without --dry-run to apply these changes.');
+    return;
+  }
+
+  // 2. Auto-enable Vertex AI API
+  console.log('  ⚙️  Enabling Vertex AI API in your project (this can take a few seconds)...');
+  try {
+    execSync(`gcloud services enable aiplatform.googleapis.com --project=${activeProject}`, { stdio: 'inherit' });
+    console.log('  ✅  Vertex AI API successfully enabled.');
+  } catch (err) {
+    console.log('  ⚠️  Could not programmatically enable Vertex AI API. Please make sure your billing is open.');
+  }
+
+  // 3. Write env config to .env
+  const envPath = path.join(process.cwd(), '.env');
+  let envContent = '';
+  if (fs.existsSync(envPath)) {
+    envContent = fs.readFileSync(envPath, 'utf8');
+  }
+
+  // Helper to update or append env values
+  function updateEnvKey(content, key, value) {
+    const regex = new RegExp(`^${key}=.*$`, 'm');
+    if (regex.test(content)) {
+      return content.replace(regex, `${key}=${value}`);
+    }
+    return content.trim() + `\n${key}=${value}\n`;
+  }
+
+  let updatedContent = updateEnvKey(envContent, 'THUMBGATE_PROVIDER_MODE', 'vertex');
+  updatedContent = updateEnvKey(updatedContent, 'VERTEX_PROJECT_ID', activeProject);
+
+  fs.writeFileSync(envPath, updatedContent, 'utf8');
+  console.log('  ✅  Wrote configuration to local .env file.');
+
+  // 4. Print gorgeous success activation box
+  console.log('');
+  console.log('  ╭──────────────────────────────────────────────────────────╮');
+  console.log('  │  Vertex AI Setup Complete                                │');
+  console.log('  │                                                         │');
+  console.log('  │  ThumbGate wrote local Vertex routing config.            │');
+  console.log('  │  This does not create or verify a Dialogflow CX agent.   │');
+  console.log('  │  Verify DFCX with the console or Dialogflow CX REST API. │');
+  console.log('  │                                                         │');
+  console.log('  │  Try a test run:                                        │');
+  console.log('  │  npx thumbgate feedback-self-test                       │');
+  console.log('  ╰──────────────────────────────────────────────────────────╯');
+  console.log('');
+}
+
 function quickStart() {
   const qsArgs = parseArgs(process.argv.slice(3));
   const projectDir = process.cwd();
@@ -657,8 +905,28 @@ function quickStart() {
   console.log('');
 }
 
+// Activation walkthrough (guided first rule + live demonstrated block).
+// Implementation lives in scripts/activation-quickstart.js so it can be unit
+// tested without executing the CLI's top-level command switch. `init` is
+// deliberately untouched — this is an additive, separate command.
+function quickstart() {
+  return require(path.join(PKG_ROOT, 'scripts', 'activation-quickstart')).quickstart();
+}
+
 function init(cliArgs = parseArgs(process.argv.slice(3))) {
   const args = { ...cliArgs };
+  if (args.help || args.h) {
+    console.log('Usage: npx thumbgate init [--agent <name>] [--wire-hooks] [--email you@company.com]');
+    console.log('');
+    console.log('Scaffold ThumbGate in the current project and wire detected agent integrations.');
+    console.log('');
+    console.log('Options:');
+    console.log('  --agent <name>           Wire a specific agent: claude-code, codex, gemini, amp, cursor, cline');
+    console.log('  --wire-hooks             Wire hooks only; do not scaffold project files');
+    console.log('  --email <email>          Subscribe installer to the setup guide and trial reminders');
+    console.log('  --dry-run                Show hook changes without writing them');
+    return;
+  }
 
   // --wire-hooks only mode: skip scaffolding, just wire hooks
   if (args['wire-hooks']) {
@@ -718,12 +986,43 @@ function init(cliArgs = parseArgs(process.argv.slice(3))) {
   // Always create .mcp.json (project-level MCP config used by Claude, Codex, Cursor)
   mergeMcpJson(path.join(CWD, '.mcp.json'), 'MCP');
 
+  // Copy custom slash commands (.claude/commands/*.md) to the project's config directories
+  const pkgCommandsDir = path.join(PKG_ROOT, '.claude', 'commands');
+  if (fs.existsSync(pkgCommandsDir)) {
+    const targets = [
+      path.join(CWD, '.claude', 'commands'),
+      path.join(CWD, '.gemini', 'commands'),
+      path.join(CWD, '.antigravitycli', 'commands')
+    ];
+    for (const projectCommandsDir of targets) {
+      if (!fs.existsSync(projectCommandsDir)) {
+        fs.mkdirSync(projectCommandsDir, { recursive: true });
+      }
+      try {
+        const files = fs.readdirSync(pkgCommandsDir);
+        for (const file of files) {
+          if (file.endsWith('.md')) {
+            fs.copyFileSync(path.join(pkgCommandsDir, file), path.join(projectCommandsDir, file));
+          }
+        }
+      } catch (err) {
+        console.log(`  Failed to copy custom commands to ${path.relative(CWD, projectCommandsDir)}: ${err.message}`);
+      }
+    }
+    console.log('Scaffolded custom slash commands directories (.claude, .gemini, .antigravitycli)');
+  }
+
   // Auto-detect and configure platform-specific locations
   console.log('');
   console.log('Detecting platforms...');
   let configured = 0;
 
   const platforms = [
+    { name: 'Claude Code', detect: [
+      () => whichExists('claude'),
+      () => fs.existsSync(path.join(HOME, '.claude')),
+      () => fs.existsSync(path.join(CWD, '.claude')),
+    ], setup: setupClaude },
     { name: 'Codex', detect: [() => whichExists('codex'), () => fs.existsSync(path.join(HOME, '.codex'))], setup: setupCodex },
     { name: 'Gemini', detect: [() => whichExists('gemini'), () => fs.existsSync(path.join(HOME, '.gemini'))], setup: setupGemini },
     { name: 'Amp', detect: [() => whichExists('amp'), () => fs.existsSync(path.join(HOME, '.amp'))], setup: setupAmp },
@@ -746,8 +1045,11 @@ function init(cliArgs = parseArgs(process.argv.slice(3))) {
   }
 
   // ChatGPT — cannot be automated
-  const chatgptSpec = path.join(PKG_ROOT, 'adapters', 'chatgpt', 'openapi.yaml');
-  if (fs.existsSync(chatgptSpec)) {
+  const chatgptSpec = [
+    path.join(PKG_ROOT, 'openapi', 'openapi.yaml'),
+    path.join(PKG_ROOT, 'adapters', 'chatgpt', 'openapi.yaml'),
+  ].find((candidate) => fs.existsSync(candidate));
+  if (chatgptSpec) {
     const projectChatgptSpec = path.join(thumbgateDir, 'chatgpt-openapi.yaml');
     fs.copyFileSync(chatgptSpec, projectChatgptSpec);
     console.log(`  ChatGPT: import ${path.relative(CWD, projectChatgptSpec)} in GPT Builder > Actions`);
@@ -787,16 +1089,43 @@ function init(cliArgs = parseArgs(process.argv.slice(3))) {
   }
 
   console.log('');
-  console.log(`thumbgate v${pkgVersion()} initialized.`);
-  console.log('Run: npx thumbgate help');
+  console.log(`✅ thumbgate v${pkgVersion()} initialized.`);
+  const onboardingEmail = typeof args.email === 'string'
+    ? args.email.trim()
+    : (typeof args['onboarding-email'] === 'string' ? args['onboarding-email'].trim() : '');
+  if (onboardingEmail) {
+    try {
+      execFileSync(process.execPath, [__filename, 'subscribe', onboardingEmail], {
+        cwd: CWD,
+        env: process.env,
+        stdio: 'inherit',
+      });
+      trackEvent('cli_init_email_subscribed', { command: 'init', source: 'init_email' });
+    } catch (_) {
+      console.log(`  Retry onboarding email: npx thumbgate subscribe ${onboardingEmail}`);
+    }
+  }
   trackEvent('cli_init', { command: 'init' });
-  proNudge();
+
+  // ---------------------------------------------------------------------------
+  // Activation guide: the ONE thing the user should do next.
+  // 98.5% of init users never promote their first prevention rule.
+  // This is the funnel break — not conversion, not nudges — activation.
+  // ---------------------------------------------------------------------------
   console.log('');
-  console.log('  ┌──────────────────────────────────────────────────────────┐');
-  console.log('  │  Teams: shared enforcement, CI gates, audit trails      │');
-  console.log('  │  One correction protects every agent on your team.      │');
-  console.log('  │  https://thumbgate-production.up.railway.app/pro        │');
-  console.log('  └──────────────────────────────────────────────────────────┘');
+  console.log('  ╭──────────────────────────────────────────────────────────╮');
+  console.log('  │  NEXT: Prove feedback capture works                     │');
+  console.log('  │                                                         │');
+  console.log('  │  npx thumbgate feedback-self-test                       │');
+  console.log('  │                                                         │');
+  console.log('  │  Then dogfood it in chat:                               │');
+  console.log('  │  thumbs down: agent skipped verification                │');
+  console.log('  ╰──────────────────────────────────────────────────────────╯');
+  console.log('');
+  printInitConversionPrompt(onboardingEmail);
+  if (!onboardingEmail) {
+    console.log('  Get trial reminders: npx thumbgate init --email you@company.com');
+  }
 
   try {
     const { appendFunnelEvent } = require(path.join(PKG_ROOT, 'scripts', 'billing'));
@@ -826,7 +1155,7 @@ function capture() {
   const { getUsage } = require(path.join(PKG_ROOT, 'scripts', 'rate-limiter'));
   const capLimit = checkLimit('capture_feedback');
   if (!capLimit.allowed) {
-    limitNudge('capture_feedback');
+    limitNudge('capture_feedback', capLimit);
     process.exit(1);
   }
   trackEvent('cli_capture', { command: 'capture' });
@@ -841,23 +1170,88 @@ function capture() {
     return;
   }
 
-  const signal = (args.feedback || '').toLowerCase();
+  // Parse pure positional arguments
+  const rawArgv = process.argv.slice(3);
+  const positionalArgs = [];
+  const BOOLEAN_FLAGS = new Set(['--json', '--verbose', '--quiet', '--dry-run', '--stats', '--summary', '--no-nudge', '--help']);
+  for (let i = 0; i < rawArgv.length; i++) {
+    const arg = rawArgv[i];
+    if (arg.startsWith('--')) {
+      if (!arg.includes('=') && !BOOLEAN_FLAGS.has(arg)) {
+        i++;
+      }
+    } else {
+      positionalArgs.push(arg);
+    }
+  }
+
+  let signal = (args.feedback || '').toLowerCase();
+  let consumedSignalArgs = 0;
+  if (!signal && positionalArgs[0]) {
+    const { detectFeedbackSignal } = require(path.join(PKG_ROOT, 'scripts', 'feedback-quality'));
+    const oneWord = positionalArgs[0];
+    const twoWords = positionalArgs.slice(0, 2).join(' ');
+    const detected = detectFeedbackSignal(twoWords) || detectFeedbackSignal(oneWord);
+    if (detected) {
+      signal = detected.signal;
+      consumedSignalArgs = detectFeedbackSignal(twoWords) ? Math.min(2, positionalArgs.length) : 1;
+    } else {
+      const firstPos = positionalArgs[0].toLowerCase();
+      if (['up', 'down', 'thumbsup', 'thumbsdown', 'thumbs_up', 'thumbs_down', 'positive', 'negative'].some(v => firstPos.includes(v))) {
+        signal = firstPos;
+        consumedSignalArgs = 1;
+      }
+    }
+  }
+
   const normalized = ['up', 'thumbsup', 'thumbs_up', 'positive'].some(v => signal.includes(v)) ? 'up'
     : ['down', 'thumbsdown', 'thumbs_down', 'negative'].some(v => signal.includes(v)) ? 'down'
     : signal;
 
   if (normalized !== 'up' && normalized !== 'down') {
-    console.error('Missing or unrecognized --feedback=up|down');
+    console.error('Missing or unrecognized --feedback=up|down (or positional argument)');
     process.exit(1);
   }
 
+  const gateAction = (args.action || '').toLowerCase();
+  if (gateAction && !['block', 'approve', 'warn'].includes(gateAction)) {
+    console.error('Unrecognized --action. Use: block (default), approve, or warn');
+    process.exit(1);
+  }
+
+  let context = args.context || '';
+  if (!context && consumedSignalArgs > 0) {
+    context = positionalArgs.slice(consumedSignalArgs).join(' ');
+  } else if (!context && positionalArgs[1]) {
+    context = positionalArgs[1];
+  }
+
+  let whatWentWrong = args['what-went-wrong'];
+  if (!whatWentWrong && consumedSignalArgs > 0 && positionalArgs.length > consumedSignalArgs + 1) {
+    whatWentWrong = positionalArgs.slice(consumedSignalArgs + 1).join(' ');
+  } else if (!whatWentWrong && positionalArgs[2]) {
+    whatWentWrong = positionalArgs[2];
+  } else if (!whatWentWrong && normalized === 'down' && context) {
+    whatWentWrong = context;
+  }
+
+  let whatToChange = args['what-to-change'];
+  if (!whatToChange && consumedSignalArgs > 0 && positionalArgs.length > consumedSignalArgs + 2) {
+    whatToChange = positionalArgs.slice(consumedSignalArgs + 2).join(' ');
+  } else if (!whatToChange && positionalArgs[3]) {
+    whatToChange = positionalArgs[3];
+  } else if (!whatToChange && normalized === 'down' && context) {
+    whatToChange = `avoid: ${context}`;
+  }
+
   const result = captureFeedback({
     signal: normalized,
-    context: args.context || '',
-    whatWentWrong: args['what-went-wrong'],
-    whatToChange: args['what-to-change'],
+    context: context,
+    whatWentWrong: whatWentWrong,
+    whatToChange: whatToChange,
     whatWorked: args['what-worked'],
     tags: args.tags,
+    gateAction: gateAction || undefined,
   });
 
   if (result.accepted) {
@@ -885,10 +1279,21 @@ function capture() {
       const pct = Math.round((capLimit.used / capLimit.limit) * 100);
       console.log(`  Usage       : ${capLimit.used}/${capLimit.limit} captures today (${pct}%)`);
       if (capLimit.remaining <= 1) {
-        console.log(`  ⚠️  Free tier limit reached. Upgrade to Pro for unlimited: https://thumbgate-production.up.railway.app/pro`);
+        console.log(`  ⚠️  Free tier limit reached. Upgrade to Pro for unlimited: https://thumbgate.ai/pro`);
       }
     }
     console.log('');
+    try {
+      const { buildCaptureReceipt } = require(path.join(PKG_ROOT, 'scripts', 'commercial-offer'));
+      console.log(buildCaptureReceipt({
+        signal: normalized,
+        feedbackId: ev.id,
+        memoryId: mem.id,
+        actionType: ev.actionType,
+      }));
+    } catch (_) {
+      // Receipt is a conversion aid, not part of feedback persistence.
+    }
     proNudge();
   } else {
     if (args.json) {
@@ -906,13 +1311,130 @@ function capture() {
   }
 }
 
+function readJsonlEntries(filePath) {
+  try {
+    return fs.readFileSync(filePath, 'utf8')
+      .split(/\r?\n/)
+      .map((line) => line.trim())
+      .filter(Boolean)
+      .map((line) => JSON.parse(line));
+  } catch (_) {
+    return [];
+  }
+}
+
+function shellSingleQuote(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+
+function feedbackSelfTest() {
+  const args = parseArgs(process.argv.slice(3));
+  const signalArg = String(args.feedback || args.signal || 'down').toLowerCase();
+  const normalized = ['up', 'thumbsup', 'thumbs_up', 'positive'].some((v) => signalArg.includes(v)) ? 'up'
+    : ['down', 'thumbsdown', 'thumbs_down', 'negative'].some((v) => signalArg.includes(v)) ? 'down'
+    : signalArg;
+
+  if (normalized !== 'up' && normalized !== 'down') {
+    console.error('feedback-self-test needs --feedback=up|down when overriding the default.');
+    process.exit(1);
+  }
+
+  const previousFeedbackDir = process.env.THUMBGATE_FEEDBACK_DIR;
+  const previousNoNudge = process.env.THUMBGATE_NO_NUDGE;
+  const feedbackDir = args['feedback-dir']
+    ? path.resolve(CWD, args['feedback-dir'])
+    : args.persist
+      ? null
+      : fs.mkdtempSync(path.join(os.tmpdir(), 'thumbgate-feedback-self-test-'));
+  const isolated = Boolean(feedbackDir);
+
+  if (feedbackDir) process.env.THUMBGATE_FEEDBACK_DIR = feedbackDir;
+  process.env.THUMBGATE_NO_NUDGE = '1';
+
+  try {
+    const { captureFeedback, getFeedbackPaths } = require(path.join(PKG_ROOT, 'scripts', 'feedback-loop'));
+    const context = args.context || `feedback self-test: typed thumbs ${normalized} reaches ThumbGate capture`;
+    const result = captureFeedback({
+      signal: normalized,
+      context,
+      whatWentWrong: normalized === 'down'
+        ? (args['what-went-wrong'] || 'Need proof that feedback capture is wired in this runtime')
+        : undefined,
+      whatToChange: normalized === 'down'
+        ? (args['what-to-change'] || 'Run a one-command self-test before claiming thumbs feedback is captured')
+        : undefined,
+      whatWorked: normalized === 'up'
+        ? (args['what-worked'] || 'Feedback capture persisted and was verified by a self-test')
+        : undefined,
+      tags: args.tags || 'self-test,dogfood,feedback-capture',
+    });
+
+    const paths = getFeedbackPaths();
+    const feedbackRows = readJsonlEntries(paths.FEEDBACK_LOG_PATH);
+    const memoryRows = readJsonlEntries(paths.MEMORY_LOG_PATH);
+    const feedbackId = result.feedbackEvent && result.feedbackEvent.id;
+    const memoryId = result.memoryRecord && result.memoryRecord.id;
+    const feedbackStored = Boolean(feedbackId && feedbackRows.some((row) => row.id === feedbackId));
+    const memoryStored = Boolean(memoryId && memoryRows.some((row) => row.id === memoryId));
+    const ok = Boolean(result.accepted && feedbackStored && memoryStored);
+
+    const payload = {
+      ok,
+      command: 'feedback-self-test',
+      signal: normalized,
+      accepted: Boolean(result.accepted),
+      feedbackId: feedbackId || null,
+      memoryId: memoryId || null,
+      feedbackStored,
+      memoryStored,
+      isolated,
+      feedbackDir: paths.FEEDBACK_DIR,
+      nextDogfoodCommand: `npx thumbgate capture --feedback=${normalized} --context=${shellSingleQuote(context)}`,
+    };
+
+    if (args.json) {
+      console.log(JSON.stringify(payload, null, 2));
+    } else if (ok) {
+      console.log('\nThumbGate feedback self-test: PASS');
+      console.log('─'.repeat(50));
+      console.log(`  Captured     : ${normalized} (${feedbackId})`);
+      console.log(`  Stored lesson: ${memoryId}`);
+      console.log(`  Storage      : ${paths.FEEDBACK_DIR}`);
+      console.log(`  Mode         : ${isolated ? 'isolated test store' : 'active ThumbGate store'}`);
+      console.log('\nDogfood in chat with:');
+      console.log(`  thumbs ${normalized}: ${context}`);
+    } else {
+      console.log('\nThumbGate feedback self-test: FAIL');
+      console.log('─'.repeat(50));
+      console.log(`  Accepted       : ${payload.accepted}`);
+      console.log(`  Feedback stored: ${feedbackStored}`);
+      console.log(`  Memory stored  : ${memoryStored}`);
+      console.log(`  Storage        : ${paths.FEEDBACK_DIR}`);
+    }
+
+    if (!ok) process.exit(2);
+  } finally {
+    if (previousFeedbackDir === undefined) delete process.env.THUMBGATE_FEEDBACK_DIR;
+    else process.env.THUMBGATE_FEEDBACK_DIR = previousFeedbackDir;
+    if (previousNoNudge === undefined) delete process.env.THUMBGATE_NO_NUDGE;
+    else process.env.THUMBGATE_NO_NUDGE = previousNoNudge;
+  }
+}
+
 function stats() {
   trackEvent('cli_stats', { command: 'stats' });
   const args = parseArgs(process.argv.slice(3));
   const { analyzeFeedback } = require(path.join(PKG_ROOT, 'scripts', 'feedback-loop'));
   const data = analyzeFeedback();
 
+  // Gate enforcement stats — runtime intercepts + configured gates
+  let gateData = { blocked: 0, warned: 0, passed: 0, byGate: {} };
+  try { gateData = require(path.join(PKG_ROOT, 'scripts', 'gates-engine')).loadStats(); } catch {}
+  let gateConfigData = { totalGates: 0, autoPromotedGates: 0, estimatedHoursSaved: '0.0', topBlocked: null, firstTimeFixRate: null };
+  try { gateConfigData = require(path.join(PKG_ROOT, 'scripts', 'gate-stats')).calculateStats(); } catch {}
+
   const avgCostOfMistake = 2.50;
+  const totalInterceptions = gateData.blocked + gateData.warned;
   const payload = {
     total: data.total,
     positives: data.totalPositive,
@@ -922,6 +1444,13 @@ function stats() {
     revenueAtRisk: Number((data.totalNegative * avgCostOfMistake).toFixed(2)),
     topTags: data.topTags || [],
     recentActivity: data.recentActivity || [],
+    gatesBlocked: gateData.blocked,
+    gatesWarned: gateData.warned,
+    totalGates: gateConfigData.totalGates,
+    autoPromotedGates: gateConfigData.autoPromotedGates,
+    estimatedHoursSaved: gateConfigData.estimatedHoursSaved,
+    topBlockedGate: gateConfigData.topBlocked ? gateConfigData.topBlocked.id : null,
+    firstTimeFixRate: gateConfigData.firstTimeFixRate,
   };
 
   if (args.json) {
@@ -935,17 +1464,36 @@ function stats() {
   console.log(`  Approval Rate   : ${payload.approvalRate}%`);
   console.log(`  Recent Trend    : ${payload.recentTrend}%`);
 
+  // Gate enforcement — the high-ROI section
+  if (totalInterceptions > 0 || payload.totalGates > 0) {
+    console.log('\n🛡️  PRE-ACTION GATE ENFORCEMENT');
+    console.log(`  Actions blocked : ${payload.gatesBlocked}`);
+    console.log(`  Actions warned  : ${payload.gatesWarned}`);
+    console.log(`  Active gates    : ${payload.totalGates} (${payload.autoPromotedGates} auto-promoted)`);
+    if (payload.topBlockedGate) console.log(`  Top blocker     : ${payload.topBlockedGate}`);
+    console.log(`  Est. time saved : ~${payload.estimatedHoursSaved} hours`);
+    const { formatFirstTimeFixRate } = require(path.join(PKG_ROOT, 'scripts', 'gate-stats'));
+    console.log(`  First-time fix  : ${formatFirstTimeFixRate(payload.firstTimeFixRate)}`);
+  }
+
   if (payload.negatives > 0) {
     console.log('\n⚠️  REVENUE-AT-RISK ANALYSIS');
     console.log(`  Repeated Failures detected: ${payload.negatives}`);
     console.log(`  Estimated Operational Loss: $${payload.revenueAtRisk}`);
     console.log('  Action Required: Run "npx thumbgate rules" to generate guardrails.');
     console.log('  Strategic Recommendation: if this is a shared workflow problem, start the Workflow Hardening Sprint.');
-    console.log('  Team intake: https://thumbgate-production.up.railway.app/#workflow-sprint-intake');
+    console.log('  Team intake: https://thumbgate.ai/#workflow-sprint-intake');
     console.log('  Solo side lane: npx thumbgate pro');
   } else {
     console.log('\n✅ System is currently high-reliability. No immediate revenue loss detected.');
   }
+  try {
+    const { buildStatsReceipt } = require(path.join(PKG_ROOT, 'scripts', 'commercial-offer'));
+    const receipt = buildStatsReceipt(payload);
+    if (receipt) console.log(receipt);
+  } catch (_) {
+    // Keep stats resilient if the receipt helper is unavailable in old installs.
+  }
   proNudge();
 }
 
@@ -1051,13 +1599,14 @@ function pro() {
   } = require(path.join(PKG_ROOT, 'scripts', 'pro-local-dashboard'));
 
   function printProInfo() {
-    const hostedUrl = 'https://thumbgate-production.up.railway.app';
+    const hostedUrl = 'https://thumbgate.ai';
     const truthUrl = 'https://github.com/IgorGanapolsky/ThumbGate/blob/main/docs/COMMERCIAL_TRUTH.md';
     console.log('\nThumbGate Pro — Local Dashboard');
     console.log('─'.repeat(50));
     console.log('Self-serve side lane today: Pro ($19/mo or $149/yr).');
     console.log('Every licensed Pro user gets a personal local dashboard on localhost.');
     console.log('\nWhat is available:');
+    console.log('  - Hosted sync: keep lessons, rules, and dashboard state aligned across laptops, CI, containers, and agent runtimes');
     console.log('  - Local Pro dashboard: your own browser dashboard for search, gates, and DPO export');
     console.log('  - Team rollout path: shared hosted lessons, org visibility, and workflow proof');
     console.log('  - Commercial truth doc: source of truth for traction, pricing, and proof claims');
@@ -1195,6 +1744,13 @@ function lessons() {
   const tags = String(args.tags || '').split(',').map((t) => t.trim()).filter(Boolean);
   const query = args.query || process.argv.slice(3).find((a) => !a.startsWith('--')) || '';
   const limit = Number(args.limit || 10);
+  const { checkLimit } = require(path.join(PKG_ROOT, 'scripts', 'rate-limiter'));
+  const searchLimit = checkLimit('search_lessons');
+  if (!searchLimit.allowed) {
+    trackEvent('cli_upgrade_prompt', { command: 'lessons', action: 'search_lessons', limitType: searchLimit.limitType || null });
+    limitNudge('search_lessons', searchLimit);
+    process.exit(1);
+  }
 
   // --remote: fetch from hosted Railway instance
   if (args.remote) {
@@ -1361,6 +1917,7 @@ function modelCandidatesCmd() {
   const maxCandidates = args.max ? Number(args.max) : undefined;
   const { reportPath, report } = writeModelCandidatesReport(undefined, {
     workload: args.workload,
+    workloadFile: args['workload-file'] || args.workloadFile,
     provider: args.provider,
     family: args.family,
     gateway: args.gateway,
@@ -1461,13 +2018,10 @@ function risk() {
 }
 
 function exportDpo() {
-  const { isProTier } = require(path.join(PKG_ROOT, 'scripts', 'rate-limiter'));
-  if (!isProTier(null)) {
-    process.stderr.write(
-      `\n  🔒 DPO Export requires Pro (${PRO_PRICE_LABEL}).\n` +
-      `     Your feedback would generate valuable training pairs.\n` +
-      `     Upgrade: ${PRO_CHECKOUT_URL}\n\n`
-    );
+  const { checkLimit } = require(path.join(PKG_ROOT, 'scripts', 'rate-limiter'));
+  const exportLimit = checkLimit('export_dpo');
+  if (!exportLimit.allowed) {
+    limitNudge('export_dpo', exportLimit);
     process.exit(1);
   }
   const extraArgs = process.argv.slice(3).join(' ');
@@ -1484,13 +2038,10 @@ function exportDpo() {
 }
 
 function exportDatabricks() {
-  const { isProTier } = require(path.join(PKG_ROOT, 'scripts', 'rate-limiter'));
-  if (!isProTier(null)) {
-    process.stderr.write(
-      `\n  🔒 Databricks Export requires Pro (${PRO_PRICE_LABEL}).\n` +
-      `     Export feedback logs + proof artifacts for analytics.\n` +
-      `     Upgrade: ${PRO_CHECKOUT_URL}\n\n`
-    );
+  const { checkLimit } = require(path.join(PKG_ROOT, 'scripts', 'rate-limiter'));
+  const exportLimit = checkLimit('export_databricks');
+  if (!exportLimit.allowed) {
+    limitNudge('export_databricks', exportLimit);
     process.exit(1);
   }
   const extraArgs = process.argv.slice(3).join(' ');
@@ -1685,6 +2236,26 @@ function pulse() {
   });
 }
 
+function checkUpdateCmd() {
+  const { checkUpdate } = require(path.join(PKG_ROOT, 'scripts', 'check-update'));
+  const args = parseArgs(process.argv.slice(3));
+  checkUpdate({ verbose: !args.json, force: args.force }).then((res) => {
+    if (args.json) {
+      console.log(JSON.stringify(res, null, 2));
+    }
+    process.exit(0);
+  }).catch((err) => {
+    console.error(err && err.message ? err.message : err);
+    process.exit(1);
+  });
+}
+
+function selfUpdateCmd() {
+  const { selfUpdate } = require(path.join(PKG_ROOT, 'scripts', 'check-update'));
+  const success = selfUpdate();
+  process.exit(success ? 0 : 1);
+}
+
 function dispatchBrief() {
   const args = parseArgs(process.argv.slice(3));
   const {
@@ -1718,6 +2289,25 @@ function gateStats() {
   console.log('\n' + formatStats(stats) + '\n');
 }
 
+function contextPacks() {
+  const args = parseArgs(process.argv.slice(3));
+  const { generateAutoContextPacks } = require(path.join(PKG_ROOT, 'scripts', 'auto-context-packs'));
+  const result = generateAutoContextPacks();
+  if (args.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log(`\nGenerated ${result.packCount} context pack(s):`);
+  for (const p of result.packs) {
+    console.log(`  [${p.type}] ${p.name}`);
+    console.log(`    -> ${p.filePath}`);
+  }
+  if (result.packCount === 0) {
+    console.log('  (No failure patterns found yet — capture some feedback first.)');
+  }
+  console.log('');
+}
+
 function harnessAudit() {
   const args = parseArgs(process.argv.slice(3));
   const {
@@ -1998,7 +2588,7 @@ function backgroundGovernance() {
   console.log('  - Run --check before dispatching an unattended PR job.');
   console.log('  - Route protected branches and large blast-radius jobs to human review.');
   console.log('  - Convert CI failures into thumbs-down lessons so repeats become Pre-Action Checks.');
-  console.log('\nGuide: https://thumbgate-production.up.railway.app/guides/background-agent-governance\n');
+  console.log('\nGuide: https://thumbgate.ai/guides/background-agent-governance\n');
 }
 
 function optimize() {
@@ -2006,6 +2596,52 @@ function optimize() {
   doOptimize();
 }
 
+function syncGcp() {
+  const { syncToGcp } = require(path.join(PKG_ROOT, 'adapters', 'gcp', 'sync.js'));
+  syncToGcp();
+}
+
+function cleanup() {
+  console.log('Cleaning up ThumbGate processes...');
+  try {
+    const { execSync } = require('child_process');
+    // Kill all 'thumbgate serve' and 'thumbgate dashboard' processes except this one
+    const pids = execSync("ps aux | grep -E 'thumbgate (serve|dashboard|mcp)' | grep -v 'grep' | grep -v 'cleanup' | awk '{print $2}'", { encoding: 'utf8' })
+      .split('\n')
+      .filter(Boolean)
+      .map(Number)
+      .filter(pid => pid !== process.pid);
+
+    if (pids.length > 0) {
+      console.log(`Killing ${pids.length} process(es): ${pids.join(', ')}`);
+      pids.forEach(pid => {
+        try { process.kill(pid, 'SIGTERM'); } catch (_) {}
+      });
+      // Give them a moment to die
+      execSync('sleep 1');
+    } else {
+      console.log('No other ThumbGate processes found.');
+    }
+
+    // Check port 3456 specifically
+    try {
+      const portPids = execSync("lsof -ti :3456", { encoding: 'utf8' })
+        .split('\n')
+        .map(s => s.trim())
+        .filter(Boolean)
+        .map(Number);
+      portPids.forEach(pid => {
+        console.log(`Killing process ${pid} holding port 3456`);
+        try { process.kill(pid, 'SIGKILL'); } catch (_) {}
+      });
+    } catch (_) { /* port already free */ }
+
+    console.log('✅ Cleanup complete. Run "npx thumbgate pro" to restart the dashboard.');
+  } catch (err) {
+    console.error(`Cleanup failed: ${err.message}`);
+  }
+}
+
 function serve() {
   try {
     const { repairCodexHooks } = require(path.join(PKG_ROOT, 'scripts', 'codex-self-heal'));
@@ -2042,11 +2678,34 @@ function install() {
 }
 
 async function gateCheck() {
-  const payload = readStdinText();
-  const input = payload ? JSON.parse(payload) : {};
-  const gatesEngine = require(path.join(PKG_ROOT, 'scripts', 'gates-engine'));
-  const output = await gatesEngine.runAsync(input);
-  process.stdout.write(output + '\n');
+  // Explicit emergency escape hatch ONLY. The 2026-06-03 hotfix made this
+  // bypass-by-default, which silently disabled ThumbGate's enforcement entirely
+  // (the firewall approved everything). Restored 2026-06-04: enforcement runs by
+  // default in warn-by-default posture (see gates-engine applyEnforcementPosture);
+  // set THUMBGATE_HOTFIX_BYPASS=1 to disable all checks if a gate ever misfires.
+  if (process.env.THUMBGATE_HOTFIX_BYPASS === '1') {
+    process.stdout.write(JSON.stringify({
+      decision: 'approve',
+      reason: 'hotfix-bypass-opt-in',
+      hookSpecificOutput: { hookEventName: 'PreToolUse', additionalContext: '' }
+    }) + '\n');
+    return;
+  }
+  try {
+    const payload = readStdinText();
+    const input = payload ? JSON.parse(payload) : {};
+    const gatesEngine = require(path.join(PKG_ROOT, 'scripts', 'gates-engine'));
+    const output = await gatesEngine.runAsync(input);
+    process.stdout.write(output + '\n');
+  } catch (err) {
+    process.stderr.write(`gate-check error: ${err.message}\n`);
+    process.stdout.write(JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: 'PreToolUse',
+        additionalContext: `[ThumbGate Error] ${err.message}`,
+      }
+    }) + '\n');
+  }
 }
 
 function cacheUpdate() {
@@ -2073,9 +2732,14 @@ function statuslineRender() {
 
 function hookAutoCapture() {
   syncActiveProjectContext();
-  const prompt = process.env.CLAUDE_USER_PROMPT || process.env.THUMBGATE_USER_PROMPT || readStdinText().trim();
+  const prompt = process.env.CLAUDE_USER_PROMPT
+    || process.env.THUMBGATE_USER_PROMPT
+    || process.env.CODEX_USER_PROMPT
+    || process.env.USER_PROMPT
+    || readStdinText().trim();
   const { evaluatePromptGuard } = require(path.join(PKG_ROOT, 'scripts', 'prompt-guard'));
   const { processInlineFeedback, formatCliOutput } = require(path.join(PKG_ROOT, 'scripts', 'cli-feedback'));
+  const { detectFeedbackSignal } = require(path.join(PKG_ROOT, 'scripts', 'feedback-quality'));
   const { loadOptionalModule } = require(path.join(PKG_ROOT, 'scripts', 'private-core-boundary'));
   const { recordConversationEntry, readRecentConversationWindow } = loadOptionalModule(
     path.join(PKG_ROOT, 'scripts', 'feedback-history-distiller'),
@@ -2097,14 +2761,12 @@ function hookAutoCapture() {
     return;
   }
 
-  const lower = prompt.toLowerCase();
-  const isUp = /(thumbs?\s*up|that worked|looks good|nice work|perfect|good job)/i.test(lower);
-  const isDown = /(thumbs?\s*down|that failed|that was wrong|fix this)/i.test(lower);
-  if (!isUp && !isDown) {
+  const detected = detectFeedbackSignal(prompt);
+  if (!detected) {
     return;
   }
 
-  const signal = isDown ? 'down' : 'up';
+  const signal = detected.signal;
   const conversationWindow = readRecentConversationWindow({ limit: 8 });
   const result = processInlineFeedback({
     signal,
@@ -2185,6 +2847,27 @@ function installMcp() {
 
 function dashboard() {
   const args = parseArgs(process.argv.slice(3));
+  if (args.open || args.web) {
+    const { resolveProjectDir } = require(path.join(PKG_ROOT, 'scripts', 'feedback-paths'));
+    const projectDir = resolveProjectDir({ cwd: process.cwd(), env: process.env });
+    const port = process.env.PORT || 3456;
+    const url = `http://127.0.0.1:${port}/dashboard?project=${encodeURIComponent(projectDir)}`;
+
+    ensureDash(Number(port))
+      .then((server) => {
+        if (server.started) {
+          console.log(`API ${port} pid ${server.pid}`);
+        }
+        return openBrowser(url);
+      })
+      .then(() => process.exit(0))
+      .catch((err) => {
+        console.error(err && err.message ? err.message : err);
+        process.exit(1);
+      });
+    return;
+  }
+
   const { printDashboard } = require(path.join(PKG_ROOT, 'scripts', 'dashboard'));
   const { getOperationalDashboard } = require(path.join(PKG_ROOT, 'scripts', 'operational-dashboard'));
 
@@ -2304,6 +2987,64 @@ function startApi() {
   }
 }
 
+function breakGlass() {
+  const args = parseArgs(process.argv.slice(3));
+  const positionalReason = process.argv.slice(3).find((arg) => !arg.startsWith('--'));
+  const reason = String(args.reason || positionalReason || '').trim();
+  if (!reason) {
+    console.error('Usage: npx thumbgate break-glass --reason "why this recovery is needed" [--ttl=5m] [--json]');
+    process.exit(1);
+  }
+
+  const ttlMs = parseTtlMs(args.ttl, 5 * 60 * 1000);
+  const { breakGlassEmergency } = require(path.join(PKG_ROOT, 'scripts', 'gates-engine'));
+  const result = breakGlassEmergency({ reason, ttlMs });
+  if (args.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+
+  console.log('ThumbGate break-glass active.');
+  console.log(`  Reason     : ${result.reason}`);
+  console.log(`  Expires    : ${result.expiresAt}`);
+  console.log('  Unlocked   : hook settings edits, pr_create_allowed, pr_threads_checked');
+  console.log('  Still gated: local-only scope, force-push, protected branch push, unsafe chmod, broad rm -rf');
+}
+
+function aiInventory() {
+  const args = parseArgs(process.argv.slice(3));
+  const {
+    scanAiComponents,
+    buildCycloneDxMlBom,
+    formatInventoryText,
+    writeOutput,
+  } = require(path.join(PKG_ROOT, 'scripts', 'ai-component-inventory'));
+  const rootDir = path.resolve(String(args.root || args.cwd || CWD));
+  const format = String(args.format || (args.json ? 'json' : 'summary')).toLowerCase();
+  const inventory = scanAiComponents({
+    rootDir,
+    maxFiles: args['max-files'] ? Number(args['max-files']) : undefined,
+    includeSnippets: args.snippets !== false,
+  });
+
+  let payload;
+  if (format === 'cyclonedx' || format === 'ml-bom' || format === 'mlbom') {
+    payload = JSON.stringify(buildCycloneDxMlBom(inventory, { version: pkgVersion() }), null, 2);
+  } else if (format === 'json') {
+    payload = JSON.stringify(inventory, null, 2);
+  } else {
+    payload = formatInventoryText(inventory);
+  }
+
+  if (args.output) {
+    writeOutput(path.resolve(String(args.output)), `${payload}\n`);
+    console.log(`Wrote AI inventory evidence to ${path.resolve(String(args.output))}`);
+    return;
+  }
+
+  console.log(payload);
+}
+
 function help() {
   const v = pkgVersion();
   const helpArgs = process.argv.slice(3);
@@ -2319,13 +3060,19 @@ function help() {
     console.log('');
     console.log('Common commands:');
     console.log('  init                                              Detect agent and wire ThumbGate hooks');
+    console.log('  feedback-self-test                                Prove thumbs capture works locally');
     console.log('  capture --feedback=up|down --context="<text>"    Capture a thumbs signal as a stored lesson');
     console.log('  stats                                             Approval rate, recent trend, blocked-pattern count');
     console.log('  lessons [query]                                   Search promoted lessons');
     console.log('  explore                                           Interactive TUI for lessons, gates, stats');
     console.log('  dashboard                                         Open the local ThumbGate dashboard');
+    console.log('  ai-inventory                                      Scan AI/ML components and export ML-BOM evidence');
     console.log('  doctor                                            Audit runtime isolation + bootstrap context');
+    console.log('  break-glass --reason="..."                       Short TTL recovery if gates over-fire');
+    console.log('  brain [--write]                                   Build the agent-readable context brain (lessons + rules + gates)');
     console.log('  pro                                               ThumbGate Pro (dashboard, exports, sync)');
+    console.log('  diagnostic                                        $499 Workflow Hardening Diagnostic for one repeated team failure');
+    console.log('  subscribe <email>                                 Get the 5-min setup guide + weekly tips by email');
     console.log('');
     console.log('More:');
     console.log('  thumbgate help all     Full subcommand surface (~70 commands)');
@@ -2371,7 +3118,11 @@ function help() {
 
   // Legacy and specialist commands kept visible until they graduate into the schema.
   console.log('Also available:');
-  console.log('  install-mcp           Install MCP server into Claude Code settings (--project for local)');
+  console.log('  install-mcp           Install MCP server + PreToolUse hooks into Claude Code settings');
+  console.log('                            default: machine-wide  (~/.claude/settings.json — shared dashboard)');
+  console.log('                            --project: per-repo    (<cwd>/.claude/settings.json — isolated dashboard)');
+  console.log('                            --no-hooks: MCP only, skip hook wiring');
+  console.log('  break-glass           Short TTL recovery if gates over-fire');
   console.log('  cfo                   Hosted billing summary (local fallback JSON)');
   console.log('  billing:setup         Generate operator key + print Railway setup instructions');
   console.log('  repair-github-marketplace  Repair legacy GitHub Marketplace amount mappings');
@@ -2392,6 +3143,7 @@ function help() {
   console.log('  proxy-pointer-rag-guardrails Map visual document RAG signals to Document RAG Safety gates');
   console.log('  rag-precision-guardrails Map retrieval tuning regressions to Document RAG Safety gates');
   console.log('  ai-engineering-stack-guardrails Map gateway, MCP, AGENTS.md, LLM wiki, reviewer, and sandbox gaps to stack gates');
+  console.log('  ai-inventory          Scan AI/ML components and export JSON or CycloneDX ML-BOM evidence');
   console.log('  upstream-contributions Find dependency issues worth fixing without promotional PRs');
   console.log('  long-running-agent-context-guardrails Map structured-memory gaps to long-running agent gates');
   console.log('  reasoning-efficiency-guardrails Map reasoning compression signals to efficiency gates');
@@ -2416,6 +3168,7 @@ function help() {
 
   console.log('Examples:');
   console.log('  npx thumbgate init');
+  console.log('  npx thumbgate feedback-self-test');
   console.log('  npx thumbgate status --json');
   console.log('  npx thumbgate explore lessons --json');
   console.log('  npx thumbgate explore gates --json');
@@ -2425,6 +3178,7 @@ function help() {
   console.log('  npx thumbgate proxy-pointer-rag-guardrails --tree-path=.rag/tree.json --image-pointers=paper-1/figures/fig2.png --documents=paper-1 --visual-claims --json');
   console.log('  npx thumbgate rag-precision-guardrails --baseline-recall=0.86 --new-recall=0.72 --threshold-change --agentic --structural-near-misses --json');
   console.log('  npx thumbgate ai-engineering-stack-guardrails --mcp-tool-count=182 --direct-provider-keys --llm-wiki-pages=24 --context-freshness-days=30 --background-agents --json');
+  console.log('  npx thumbgate ai-inventory --format=cyclonedx --output=.thumbgate/ai-mlbom.json');
   console.log('  npx thumbgate long-running-agent-context-guardrails --request-count=80 --output-mb=3 --raw-chat-only --json');
   console.log('  npx thumbgate reasoning-efficiency-guardrails --baseline-tokens=1200 --compressed-tokens=980 --baseline-accuracy=0.84 --compressed-accuracy=0.85 --verifier --json');
   console.log('  npx thumbgate deepseek-v4-runtime-guardrails --context-tokens=900000 --hybrid-attention --speculative-decoding --accept-length=1.4 --precision-mode=fp8 --json');
@@ -2446,11 +3200,271 @@ if (COMMAND === 'daemon' || COMMAND === 'serve-daemon') {
   process.exit(0);
 }
 
+// ---------------------------------------------------------------------------
+// Global --help interceptor: `thumbgate <cmd> --help` shows per-command help
+// instead of running the command. Commands with their own --help guard (init)
+// handle it internally; everything else falls through here.
+// ---------------------------------------------------------------------------
+const _cliSubArgs = process.argv.slice(3);
+const _wantsHelp = _cliSubArgs.includes('--help') || _cliSubArgs.includes('-h');
+
+const SUBCOMMAND_HELP = {
+  capture:       'Usage: npx thumbgate capture --feedback=up|down --context="..." [--what-worked="..."] [--what-went-wrong="..."] [--what-to-change="..."] [--tags=a,b]',
+  feedback:      'Usage: npx thumbgate feedback --feedback=up|down --context="..." [--what-worked="..."] [--what-went-wrong="..."] [--what-to-change="..."] [--tags=a,b]',
+  'feedback-self-test': 'Usage: npx thumbgate feedback-self-test [--json] [--persist] [--feedback=up|down]\n\nCapture a synthetic thumbs signal and verify feedback-log + memory-log writes. Defaults to an isolated test store; use --persist to dogfood the active ThumbGate store.',
+  dogfood:       'Usage: npx thumbgate dogfood [--json] [--persist] [--feedback=up|down]\n\nAlias for feedback-self-test.',
+  stats:         'Usage: npx thumbgate stats\n\nShow gate enforcement statistics: blocked/warned counts, active gates, time saved.',
+  trial:         'Usage: npx thumbgate trial\n\nShow Pro trial status, remaining days, and upgrade path.',
+  pro:           'Usage: npx thumbgate pro [--activate <key>]\n\nLaunch the local Pro dashboard or activate a Pro license key.',
+  diagnostic:    'Usage: npx thumbgate diagnostic\n\nShow the $499 Workflow Hardening Diagnostic intake and checkout paths for teams with one repeated AI-agent workflow failure.',
+  subscribe:     'Usage: npx thumbgate subscribe <email>\n\nSubscribe to the 5-minute setup guide + trial reminders.',
+  lessons:       'Usage: npx thumbgate lessons [--query="..."] [--limit=N]\n\nSearch the lesson database (Pro feature).',
+  search:        'Usage: npx thumbgate search <query>\n\nSearch ThumbGate knowledge base (Pro feature).',
+  'gate-check':  'Usage: npx thumbgate gate-check\n\nPreToolUse hook interface: reads tool call JSON from stdin, outputs gate verdict.',
+  'hermes-gate': 'Usage: npx thumbgate hermes-gate\n\nNous Research Hermes Agent pre_tool_call shell hook: reads Hermes tool-call JSON from stdin, runs the ThumbGate gate pipeline (strict by default), and outputs {"decision":"block","reason":...} to veto or {} to allow. Gates terminal/patch/skill_manage etc. See adapters/hermes/config.yaml.',
+  'break-glass': 'Usage: npx thumbgate break-glass --reason="why" [--ttl=5m] [--json]\n\nShort-lived recovery path for over-firing gates. Allows hook settings edits and satisfies PR-create/thread-check gates without disabling core destructive-action protections.',
+  serve:         'Usage: npx thumbgate serve\n\nStart the MCP stdio server. This is for agent runtimes, not the local HTTP dashboard.',
+  mcp:           'Usage: npx thumbgate mcp\n\nAlias for `thumbgate serve`.',
+  dashboard:     'Usage: npx thumbgate dashboard [--window=today|7d|30d] [--open]\n\nPrint the operational dashboard summary or open the browser HTTP dashboard (use --open). Defaults to PORT=3456.',
+  'start-api':   'Usage: npx thumbgate start-api\n\nStart the local ThumbGate HTTP API/dashboard. Defaults to PORT=8787; use PORT=3456 for statusline localhost links.',
+  'export-dpo':  'Usage: npx thumbgate export-dpo [--format=jsonl|csv]\n\nExport feedback as DPO training pairs (Pro feature).',
+  status:        'Usage: npx thumbgate status\n\nShow ThumbGate system health and active configuration.',
+  watch:         'Usage: npx thumbgate watch\n\nWatch for feedback changes and auto-regenerate prevention rules.',
+  compact:       'Usage: npx thumbgate compact\n\nCompact the lesson database and reclaim disk space.',
+  'context-packs': 'Usage: npx thumbgate context-packs\n\nGenerate context packs from top failure patterns.',
+  suggest:       'Usage: npx thumbgate suggest <gate-id>\n\nSuggest fixes for a specific gate based on lesson history.',
+  cost:          'Usage: npx thumbgate cost [--json] [--stats <path>] [--mix \'{"claude-sonnet-4-5":0.8,...}\']\n\nShow cumulative $ and tokens saved by PreToolUse gate blocks. Reads ~/.thumbgate/gate-stats.json.',
+  savings:       'Usage: npx thumbgate savings [--json] [--stats <path>] [--mix \'{"claude-sonnet-4-5":0.8,...}\']\n\nAlias for `thumbgate cost`.',
+  'setup-vertex': 'Usage: npx thumbgate setup-vertex [--dry-run]\n\nAuto-enable Vertex AI API on GCP and write local Vertex routing config to .env. With --dry-run, only detect the active account/project and print the planned changes. This does not create or verify a Dialogflow CX agent; use the Dialogflow CX REST API or console for live-agent evidence.',
+  'ai-inventory': 'Usage: npx thumbgate ai-inventory [--root <dir>] [--format=summary|json|cyclonedx] [--output <path>] [--max-files=N]\n\nScan source/manifests/model artifacts for AI, ML, agent-framework, vector DB, Vertex, Gemini, and Dialogflow CX components. Use --format=cyclonedx to produce exportable ML-BOM evidence for enterprise reviews.',
+  brain: 'Usage: npx thumbgate brain [--write] [--json] [--limit=N]\n\nBuild the agent-readable "context brain" — a single artifact consolidating this\nrepo\'s lessons, prevention rules, active gates, and project context for a coding\nagent to read BEFORE acting. --write saves it to .thumbgate/BRAIN.md (versioned,\ndeterministic). --json emits the structured model. --limit caps lessons (default 15).',
+  'team-sync': 'Usage: npx thumbgate team-sync\n\nSynchronize prevention rules and context brain with your team\'s git repository (git pull --rebase & git push), then auto-rebuild the local brain.',
+};
+
+if (_wantsHelp && COMMAND && SUBCOMMAND_HELP[COMMAND]) {
+  console.log(SUBCOMMAND_HELP[COMMAND]);
+  process.exit(0);
+}
+
+// -----------------------------------------------------------------------------
+// brain — consolidate ThumbGate's institutional memory (lessons + prevention
+// rules + active gates + project context) into a single, versioned,
+// agent-readable "context brain". The persistent context a coding agent should
+// read BEFORE acting, so it stops repeating mistakes. Composes the existing
+// explore-subcommands primitives; output is deterministic (no volatile
+// timestamp) so `.thumbgate/BRAIN.md` diffs only when the underlying memory
+// changes.
+// -----------------------------------------------------------------------------
+function buildBrainModel(opts = {}) {
+  const { exploreLessons, exploreRules, exploreGates } = require(path.join(PKG_ROOT, 'scripts', 'explore-subcommands'));
+  let feedbackDir;
+  try {
+    const { getFeedbackPaths } = require(path.join(PKG_ROOT, 'scripts', 'feedback-loop'));
+    feedbackDir = getFeedbackPaths().FEEDBACK_DIR;
+  } catch (_) { feedbackDir = path.join(CWD, '.thumbgate'); }
+  const limit = Math.max(1, Number(opts.limit) || 15);
+  const safe = (fn, fallback) => { try { return fn(); } catch (_) { return fallback; } };
+  const lessons = safe(() => exploreLessons({ feedbackDir, pkgRoot: PKG_ROOT, limit, json: true }), { lessons: [], total: 0 });
+  const rules = safe(() => exploreRules({ feedbackDir, pkgRoot: PKG_ROOT, json: true }), { rules: [], total: 0 });
+  const gates = safe(() => exploreGates({ feedbackDir, pkgRoot: PKG_ROOT, json: true }), { gates: [], total: 0 });
+  const instructionFiles = ['CLAUDE.md', 'AGENTS.md', 'GEMINI.md', '.cursorrules', '.thumbgate/config.json']
+    .filter((f) => { try { return fs.existsSync(path.join(CWD, f)); } catch (_) { return false; } });
+  return { lessons, rules, gates, project: { root: CWD, instructionFiles } };
+}
+
+function renderBrainMarkdown(model) {
+  const out = [];
+  out.push('# ThumbGate Context Brain');
+  out.push('');
+  out.push('<!-- The persistent context a coding agent should read BEFORE acting in this repo.');
+  out.push('     Generated by `npx thumbgate brain`. Rebuild after capturing feedback. -->');
+  out.push('');
+  out.push('> Institutional memory for AI coding agents working here: what has been');
+  out.push('> learned, what to avoid, and what is enforced. Read this first.');
+  out.push('');
+
+  out.push('## What this codebase taught its agents (lessons)');
+  out.push('');
+  const lessons = (model.lessons && model.lessons.lessons) || [];
+  if (!lessons.length) {
+    out.push('_No lessons captured yet. Run `npx thumbgate capture --feedback=down --context="what failed"`._');
+  } else {
+    for (const l of lessons) {
+      const sig = String(l.signal || '').toLowerCase();
+      const mark = (sig.includes('positive') || sig === 'up') ? '✅' : ((sig.includes('negative') || sig === 'down') ? '⛔' : '•');
+      const enforced = l.confidence === 'active' ? ' _(enforced)_' : '';
+      const ctx = String(l.context || '').replace(/\s+/g, ' ').trim().slice(0, 220);
+      if (ctx) out.push(`- ${mark} ${ctx}${enforced}`);
+    }
+  }
+  out.push('');
+
+  out.push('## Guardrails — do NOT repeat these (prevention rules)');
+  out.push('');
+  const rules = (model.rules && model.rules.rules) || [];
+  if (!rules.length) {
+    out.push('_No prevention rules yet._');
+  } else {
+    for (const r of rules) {
+      out.push(`- **${String(r.title || '').trim()}**`);
+      const body = String(r.body || '').split('\n')[0].trim();
+      if (body && body !== r.title) out.push(`  - ${body.slice(0, 200)}`);
+    }
+  }
+  out.push('');
+
+  out.push('## Active enforcement (gates)');
+  out.push('');
+  const gates = (model.gates && model.gates.gates) || [];
+  if (!gates.length) {
+    out.push('_No active gates._');
+  } else {
+    for (const g of gates) {
+      const occ = g.occurrences ? ` (${g.occurrences}×)` : '';
+      out.push(`- \`${g.pattern || g.id}\` → **${g.action}**${occ}`);
+    }
+  }
+  out.push('');
+
+  out.push('## Project context');
+  out.push('');
+  out.push(`- Repo root: \`${model.project.root}\``);
+  const files = model.project.instructionFiles;
+  out.push(`- Agent instruction files: ${files.length ? files.map((f) => '`' + f + '`').join(', ') : '_none detected_'}`);
+  out.push('');
+  out.push('---');
+  const lt = (model.lessons && model.lessons.total) || 0;
+  const rt = (model.rules && model.rules.total) || 0;
+  const gt = (model.gates && model.gates.total) || 0;
+  out.push(`_${lt} lessons · ${rt} rules · ${gt} gates. Rebuild with \`npx thumbgate brain --write\`._`);
+  out.push('');
+  return out.join('\n');
+}
+
+function cmdBrain(args = {}) {
+  const model = buildBrainModel({ limit: args.limit });
+  if (args.json) { console.log(JSON.stringify(model, null, 2)); return 0; }
+  const md = renderBrainMarkdown(model);
+  if (args.write) {
+    const dir = path.join(CWD, '.thumbgate');
+    const target = path.join(dir, 'BRAIN.md');
+    try {
+      fs.mkdirSync(dir, { recursive: true });
+      fs.writeFileSync(target, md);
+    } catch (err) {
+      // Surface a clean, actionable error instead of an uncaught stack trace
+      // (e.g. permission denied, read-only filesystem).
+      console.error(`Could not write ${target}: ${err && err.message ? err.message : err}`);
+      return 1;
+    }
+    const lt = (model.lessons && model.lessons.total) || 0;
+    const rt = (model.rules && model.rules.total) || 0;
+    const gt = (model.gates && model.gates.total) || 0;
+    console.log(`\u{1f9e0} Wrote context brain to .thumbgate/BRAIN.md (${lt} lessons · ${rt} rules · ${gt} gates).`);
+    console.log('   Point your agent at it: add "Read .thumbgate/BRAIN.md first" to CLAUDE.md / AGENTS.md.');
+    return 0;
+  }
+  process.stdout.write(md);
+  return 0;
+}
+
+async function teamSync() {
+  const { execSync } = require('child_process');
+
+  // Verify we are in a Git repo
+  try {
+    execSync('git rev-parse --is-inside-work-tree', { stdio: 'ignore', cwd: CWD });
+  } catch (err) {
+    console.error('❌ Error: The current directory is not a Git repository.');
+    process.exit(1);
+  }
+
+  console.log('🔄 Checking shared prevention rules status...');
+
+  const rulesRelative = '.thumbgate/prevention-rules.md';
+  const brainRelative = '.thumbgate/BRAIN.md';
+  const rulesPath = path.join(CWD, rulesRelative);
+
+  if (!fs.existsSync(rulesPath)) {
+    console.log('⚠️  No local prevention rules file found to sync.');
+  }
+
+  let statusOutput = '';
+  try {
+    statusOutput = execSync('git status --porcelain', { encoding: 'utf8', cwd: CWD }) || '';
+  } catch (_) {}
+  const hasLocalChanges = statusOutput.includes(rulesRelative) || statusOutput.includes(brainRelative) || statusOutput.includes('.thumbgate/');
+
+  if (hasLocalChanges) {
+    console.log('📝 Local changes detected in prevention rules. Committing locally...');
+    try {
+      const filesToAdd = [rulesRelative, brainRelative].filter(f => fs.existsSync(path.join(CWD, f)));
+      if (filesToAdd.length > 0) {
+        const filesStr = filesToAdd.map(f => `"${f}"`).join(' ');
+        execSync(`git add -f ${filesStr}`, { cwd: CWD });
+        execSync('git commit -m "chore(thumbgate): update shared prevention rules [skip ci]"', { cwd: CWD });
+        console.log('✅ Local rules committed successfully.');
+      } else {
+        console.log('✨ No local rules files exist to commit.');
+      }
+    } catch (e) {
+      console.log('✨ No changes to commit (already staged/clean).');
+    }
+  } else {
+    console.log('✨ No local rules changes to commit.');
+  }
+
+  // Pull from remote
+  console.log('📥 Pulling rules from teammate remote (git pull --rebase)...');
+  try {
+    execSync('git pull --rebase', { stdio: 'inherit', cwd: CWD });
+  } catch (pullErr) {
+    console.error('❌ Git pull failed. Please resolve conflicts manually.');
+    process.exit(1);
+  }
+
+  // Push to remote
+  console.log('📤 Pushing rules to teammate remote (git push)...');
+  try {
+    execSync('git push', { stdio: 'inherit', cwd: CWD });
+  } catch (pushErr) {
+    console.error('❌ Git push failed. You may need to run git push manually.');
+    process.exit(1);
+  }
+
+  // Rebuild the context brain (.thumbgate/BRAIN.md) from the newly merged rules
+  console.log('🧠 Rebuilding local context brain from merged rules...');
+  try {
+    const brainArgs = { write: true };
+    cmdBrain(brainArgs);
+  } catch (brainErr) {
+    console.warn(`⚠️  Failed to rebuild context brain: ${brainErr.message}`);
+  }
+
+  console.log('\n🚀 Team rules synchronization complete! Your agents now share team-wide learning.');
+}
+
 switch (COMMAND) {
+  case 'team-sync':
+  case 'git-sync':
+    teamSync().catch((err) => {
+      console.error(err && err.message ? err.message : err);
+      process.exit(1);
+    });
+    break;
+  case '--version':
+  case '-v':
+  case 'version':
+    console.log(pkgVersion());
+    break;
   case 'init':
     init();
     upgradeNudge();
     break;
+  case 'quickstart':
+  case 'first-rule':
+    quickstart();
+    break;
   case 'quick-start':
     quickStart();
     break;
@@ -2464,6 +3478,12 @@ switch (COMMAND) {
   case 'mcp':
     serve();
     break;
+  case 'cleanup':
+    cleanup();
+    break;
+  case 'sync-gcp':
+    syncGcp();
+    break;
   case 'gate-check':
     gateCheck().catch((err) => {
       console.error(err && err.message ? err.message : err);
@@ -2487,6 +3507,16 @@ switch (COMMAND) {
     capture();
     upgradeNudge();
     break;
+  case 'feedback-self-test':
+  case 'dogfood':
+    feedbackSelfTest();
+    break;
+  case 'setup-vertex':
+    setupVertex(parseArgs(process.argv.slice(3))).catch((err) => {
+      console.error(err && err.message ? err.message : err);
+      process.exit(1);
+    });
+    break;
   case 'stats':
     stats();
     upgradeNudge();
@@ -2495,6 +3525,27 @@ switch (COMMAND) {
   case 'revenue':
     cfo();
     break;
+  case 'cost':
+  case 'savings':
+  case 'costs': {
+    const { main: costMain } = require(path.join(PKG_ROOT, 'scripts', 'cost-cli'));
+    process.exit(costMain(process.argv.slice(3)));
+    // process.exit doesn't return, but keep an explicit break so the switch
+    // cannot accidentally fall through to case 'billing:setup' if a future
+    // refactor wraps costMain in try/finally that intercepts the exit, or
+    // a test runner stubs process.exit (flagged by gitar-bot on PR #2281).
+    break;
+  }
+  case 'brain': {
+    const sub = process.argv.slice(3).find((arg) => !arg.startsWith('--'));
+    if (sub && ['init', 'context', 'remember', 'check', 'cleanup', 'status'].includes(sub)) {
+      brain();
+    } else {
+      const brainArgs = parseArgs(process.argv.slice(3));
+      process.exitCode = cmdBrain(brainArgs);
+    }
+    break;
+  }
   case 'billing:setup':
     require(path.join(PKG_ROOT, 'scripts', 'billing-setup'));
     break;
@@ -2511,6 +3562,11 @@ switch (COMMAND) {
   case 'search-lessons':
     lessons();
     break;
+  case 'notes': {
+    const { cli: notesCli } = require(path.join(PKG_ROOT, 'scripts', 'implementation-notes'));
+    notesCli(process.argv.slice(3));
+    break;
+  }
   case 'lesson-health':
   case 'stale': {
     const { initDB } = require(path.join(PKG_ROOT, 'scripts', 'lesson-db'));
@@ -2652,6 +3708,9 @@ switch (COMMAND) {
   case 'rules':
     rules();
     break;
+  case 'context-packs':
+    contextPacks();
+    break;
   case 'harness-audit':
   case 'harness':
     harnessAudit();
@@ -2681,6 +3740,12 @@ switch (COMMAND) {
   case 'llm-wiki-guardrails':
     aiEngineeringStackGuardrails();
     break;
+  case 'ai-inventory':
+  case 'ai-component-inventory':
+  case 'ml-bom':
+  case 'mlbom':
+    aiInventory();
+    break;
   case 'deepseek-v4-runtime-guardrails':
   case 'deepseek-runtime-guardrails':
   case 'sparse-attention-runtime-guardrails':
@@ -2745,9 +3810,90 @@ switch (COMMAND) {
   case 'self-heal':
     selfHeal();
     break;
+  case 'workflow':
+  case 'swarm': {
+    const args = parseArgs(process.argv.slice(3));
+    let objective = args.objective;
+    if (!objective) {
+      const firstPositional = process.argv.slice(3).find((a, idx, arr) => {
+        if (a.startsWith('--')) return false;
+        const prev = arr[idx - 1];
+        if (prev && prev.startsWith('--') && !prev.includes('=')) return false;
+        return true;
+      });
+      if (firstPositional) objective = firstPositional;
+    }
+    if (!objective) {
+      console.error('Error: objective is required. Run with --objective="your objective" or provide it as a positional argument.');
+      process.exit(1);
+    }
+    const { executeWorkflow } = require(path.join(PKG_ROOT, 'scripts', 'parallel-workflow-orchestrator'));
+    const concurrency = args.concurrency ? Number(args.concurrency) : undefined;
+    const timeoutMs = args.timeoutMs ? Number(args.timeoutMs) : undefined;
+    executeWorkflow(objective, { concurrency, timeoutMs, cwd: CWD })
+      .then((res) => {
+        if (args.json) {
+          console.log(JSON.stringify(res, null, 2));
+        } else {
+          console.log(`\n✅ Parallel workflow execution complete.`);
+          console.log(`  Workflow ID: ${res.workflowId}`);
+          console.log(`  Objective  : ${res.objective}`);
+          console.log(`  Duration   : ${(res.durationMs / 1000).toFixed(2)}s`);
+          console.log(`  Report Path: ${res.reportPath}`);
+          console.log(`\nReport Summary:\n`);
+          console.log(fs.readFileSync(res.reportPath, 'utf8'));
+        }
+        process.exit(0);
+      })
+      .catch((err) => {
+        console.error('Workflow execution failed:', err.message);
+        process.exit(1);
+      });
+    break;
+  }
+  case 'trial': {
+    // Show trial status — connects the 4K monthly npm installers to checkout
+    const { isProTier, isInTrialPeriod, trialDaysRemaining, getInstallAgeDays } = require(path.join(PKG_ROOT, 'scripts', 'rate-limiter'));
+    const ageDays = getInstallAgeDays();
+    const inTrial = isInTrialPeriod();
+    const remaining = trialDaysRemaining();
+    const isPro = isProTier();
+    console.log('');
+    console.log('  ThumbGate Pro Trial');
+    console.log('  ──────────────────');
+    if (isPro && !inTrial) {
+      console.log('  Status: ✅ Pro (active license or API key)');
+    } else if (inTrial) {
+      const expiryDate = new Date(Date.now() + remaining * 86400000).toLocaleDateString('en-US', { month: 'long', day: 'numeric', year: 'numeric' });
+      console.log(`  Status: 🎁 Active (${remaining} day${remaining === 1 ? '' : 's'} remaining)`);
+      console.log(`  Expires: ${expiryDate}`);
+      console.log('');
+      console.log('  All Pro features unlocked:');
+      console.log('    • Unlimited prevention rules (free tier: 5)');
+      console.log('    • Recall, lesson search, DPO export');
+      console.log('    • Cross-machine sync via API key');
+    } else {
+      console.log('  Status: ⏰ Expired');
+      if (ageDays !== null) {
+        console.log(`  Installed: ${Math.floor(ageDays)} days ago`);
+      }
+      console.log('');
+      console.log('  Free tier: 5 active rules, no recall/search/export');
+    }
+    console.log('');
+    console.log(`  Keep Pro: ${PRO_CHECKOUT_URL}`);
+    console.log(`  Or set: THUMBGATE_API_KEY=<your-key>`);
+    console.log('');
+    break;
+  }
   case 'pro':
     pro();
     break;
+  case 'diagnostic':
+  case 'workflow-diagnostic':
+  case 'sprint-diagnostic':
+    diagnostic();
+    break;
   case 'activate':
     // Top-level alias: npx thumbgate activate <key>
     process.argv.splice(3, 0, '--activate');
@@ -2762,12 +3908,24 @@ switch (COMMAND) {
   case 'status':
     status();
     break;
+  case 'break-glass':
+  case 'breakglass':
+    breakGlass();
+    break;
   case 'funnel':
     funnel();
     break;
   case 'pulse':
     pulse();
     break;
+  case 'check-update':
+  case 'upgrade-check':
+    checkUpdateCmd();
+    break;
+  case 'self-update':
+  case 'upgrade-cli':
+    selfUpdateCmd();
+    break;
   case 'dispatch':
   case 'dispatch-brief':
     dispatchBrief();
@@ -2776,6 +3934,7 @@ switch (COMMAND) {
     // PreToolUse hook interface: reads tool call JSON from stdin, outputs gate verdict
     // Used by: generate-pretool-hook.sh → npx thumbgate gate-check
     const { run: gateRun, runAsync: gateRunAsync } = require(path.join(PKG_ROOT, 'scripts', 'gates-engine'));
+    const { evaluateSelfProtection } = require(path.join(PKG_ROOT, 'scripts', 'self-protection'));
     let stdinData = '';
     process.stdin.setEncoding('utf8');
     process.stdin.on('data', (chunk) => { stdinData += chunk; });
@@ -2783,7 +3942,32 @@ switch (COMMAND) {
       try {
         const input = JSON.parse(stdinData);
         const output = await gateRunAsync(input);
-        process.stdout.write(output + '\n');
+        // Self-protection overlay (2026-07-08): the gate engine only denies edits
+        // to ThumbGate's own governance files under strict enforcement; by default
+        // such edits pass as a clean ALLOW. Surface them (or block in strict) so an
+        // agent can't silently disable the firewall. Only overlays when the engine
+        // did not already produce a hard deny.
+        let verdict = output;
+        try {
+          const parsed = JSON.parse(output || '{}');
+          const alreadyDeny = (parsed.hookSpecificOutput && parsed.hookSpecificOutput.permissionDecision === 'deny')
+            || parsed.decision === 'block';
+          if (!alreadyDeny) {
+            const sp = evaluateSelfProtection(input.tool_name, input.tool_input);
+            if (sp && sp.action === 'block') {
+              verdict = JSON.stringify({
+                decision: 'block',
+                reason: sp.message,
+                hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: sp.message },
+              });
+            } else if (sp && sp.action === 'warn') {
+              verdict = JSON.stringify({
+                hookSpecificOutput: { hookEventName: 'PreToolUse', additionalContext: sp.message },
+              });
+            }
+          }
+        } catch (_e) { /* non-JSON engine output: pass through unchanged */ }
+        process.stdout.write(verdict + '\n');
         process.exit(0);
       } catch (err) {
         process.stderr.write(`gate-check error: ${err.message}\n`);
@@ -2793,6 +3977,53 @@ switch (COMMAND) {
     });
     break;
   }
+  case 'hermes-gate': {
+    // Nous Research Hermes Agent `pre_tool_call` shell hook.
+    // Hermes pipes each pending tool call as JSON to stdin and reads a decision from stdout;
+    // {"decision":"block","reason":...} vetoes the call. We reuse the SAME gate pipeline as
+    // `gate-check` (runAsync → secret guard, security scan, force-push / skill_manage / learned
+    // prevention rules) and translate the verdict into Hermes's format.
+    //
+    // Hermes `pre_tool_call` is binary (block or allow) with no warn channel, and the whole point
+    // of wiring it is to gate, so we run STRICT enforcement by default — otherwise ThumbGate's
+    // warn-by-default posture would pass every deny through and the hook would block nothing.
+    // Opt out with THUMBGATE_HERMES_WARN_ONLY=1; THUMBGATE_HOTFIX_BYPASS=1 still disables checks.
+    // Wire it in ~/.hermes/config.yaml — see adapters/hermes/config.yaml.
+    if (process.env.THUMBGATE_HERMES_WARN_ONLY !== '1' && process.env.THUMBGATE_HOTFIX_BYPASS !== '1') {
+      process.env.THUMBGATE_STRICT_ENFORCEMENT = '1';
+    }
+    const { runAsync: hermesGateRun } = require(path.join(PKG_ROOT, 'scripts', 'gates-engine'));
+    let hermesStdin = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => { hermesStdin += chunk; });
+    process.stdin.on('end', async () => {
+      try {
+        const payload = JSON.parse(hermesStdin);
+        // Hermes sends snake_case tool_name/tool_input — gates-engine reads these directly.
+        const verdict = await hermesGateRun({ tool_name: payload.tool_name, tool_input: payload.tool_input });
+        let parsed = {};
+        try { parsed = JSON.parse(verdict); } catch (_e) { parsed = {}; }
+        const hso = parsed.hookSpecificOutput || {};
+        if (hso.permissionDecision === 'deny') {
+          process.stdout.write(JSON.stringify({
+            decision: 'block',
+            reason: hso.permissionDecisionReason || 'Blocked by ThumbGate prevention rule.',
+          }) + '\n');
+        } else {
+          // warn / no match → allow. The gate engine already logged the decision.
+          process.stdout.write(JSON.stringify({}) + '\n');
+        }
+        process.exit(0);
+      } catch (err) {
+        // Hermes hooks fail OPEN on error/timeout — emit an explicit allow so a gate fault
+        // never wedges the agent (reliability ≈ enforcement; keep this fast).
+        process.stderr.write(`hermes-gate error: ${err.message}\n`);
+        process.stdout.write(JSON.stringify({}) + '\n');
+        process.exit(0);
+      }
+    });
+    break;
+  }
   case 'gate-stats':
     gateStats();
     break;
@@ -2847,6 +4078,29 @@ switch (COMMAND) {
     }
     break;
   }
+  case 'audit': {
+    const auditFile = process.argv[3];
+    if (!auditFile) {
+      console.error('Usage: npx thumbgate audit <path-to-transcript.txt>');
+      process.exit(1);
+    }
+    const { runAudit } = require(path.join(PKG_ROOT, 'scripts', 'audit'));
+    const { results, totalWaste, error } = runAudit(auditFile);
+    if (error) {
+      console.error(error);
+      process.exit(1);
+    }
+    console.log('\n🔍 AI Bill Audit Results\n');
+    if (results.length === 0) {
+      console.log('✅ No repeat-offender patterns found. Your sessions are efficient!');
+    } else {
+      console.table(results);
+      console.log('\n💰 Total estimated monthly waste: $' + totalWaste);
+      console.log('\nBlock these mistakes permanently with ThumbGate Pro:');
+      console.log(PRO_CHECKOUT_URL);
+    }
+    break;
+  }
   case 'dashboard':
     dashboard();
     break;
@@ -2870,6 +4124,86 @@ switch (COMMAND) {
   case 'compact':
     compact();
     break;
+  case 'subscribe': {
+    // Capture an installer's email so we can send the 5-minute setup
+    // guide + weekly tips. Drops to /v1/marketing/install-email on the
+    // hosted endpoint; the server fires sendNewsletterWelcomeEmail via
+    // Resend and persists the address for follow-up.
+    //
+    // Usage:
+    //   npx thumbgate subscribe you@company.com
+    //   npx thumbgate subscribe --email=you@company.com
+    //
+    // Never prompts interactively — postinstall must stay non-interactive
+    // for CI safety. This is the deliberate opt-in path the banner points
+    // at; if the operator runs it, they want the email.
+    const args = process.argv.slice(3);
+    let email = '';
+    for (const arg of args) {
+      if (arg.startsWith('--email=')) email = arg.slice('--email='.length).trim();
+      else if (!arg.startsWith('--')) email = arg.trim();
+    }
+    if (!email || !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
+      console.error('Usage: npx thumbgate subscribe <email>');
+      console.error('       npx thumbgate subscribe --email=you@company.com');
+      console.error('');
+      console.error('We send a 5-minute setup guide + weekly tips. One-click unsubscribe.');
+      process.exit(1);
+    }
+    const endpoint = process.env.THUMBGATE_INSTALL_EMAIL_ENDPOINT
+      || 'https://thumbgate.ai/v1/marketing/install-email';
+    const payload = JSON.stringify({
+      email,
+      source: 'cli_subscribe',
+      installId: (() => {
+        try {
+          const configPath = path.join(CWD, '.thumbgate', 'config.json');
+          if (!fs.existsSync(configPath)) return null;
+          return (JSON.parse(fs.readFileSync(configPath, 'utf8')).installId) || null;
+        } catch { return null; }
+      })(),
+      cliVersion: pkgVersion(),
+    });
+    const url = new URL(endpoint);
+    const transport = url.protocol === 'https:' ? require('node:https') : require('node:http');
+    const req = transport.request({
+      method: 'POST',
+      hostname: url.hostname,
+      port: url.port || (url.protocol === 'https:' ? 443 : 80),
+      path: url.pathname + url.search,
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(payload),
+        'User-Agent': `thumbgate-cli/${pkgVersion()}`,
+      },
+      timeout: 8000,
+    }, (res) => {
+      let body = '';
+      res.on('data', (chunk) => { body += chunk; });
+      res.on('end', () => {
+        if (res.statusCode >= 200 && res.statusCode < 300) {
+          console.log(`✓ Subscribed ${email}.`);
+          console.log('  Check your inbox in ~30 seconds for the setup guide.');
+          console.log('  Unsubscribe link is in every email.');
+          process.exit(0);
+        } else {
+          console.error(`✗ Subscribe failed: HTTP ${res.statusCode}${body ? ` — ${body.slice(0, 200)}` : ''}`);
+          process.exit(2);
+        }
+      });
+    });
+    req.on('error', (err) => {
+      console.error(`✗ Subscribe failed: ${err.message}`);
+      console.error('  Network issue? Try again, or email igor.ganapolsky@gmail.com directly.');
+      process.exit(3);
+    });
+    req.on('timeout', () => {
+      req.destroy(new Error('timeout after 8000ms'));
+    });
+    req.write(payload);
+    req.end();
+    break;
+  }
   case 'checkin': {
     // User check-in command — asks how it's going after install
     const thumbgateDir = path.join(CWD, '.thumbgate');