thumbgate 1.17.0 → 1.18.0

package/.claude-plugin/marketplace.json

@@ -1,6 +1,6 @@
 {
   "name": "thumbgate-marketplace",
-  "version": "1.17.0",
+  "version": "1.18.0",
   "owner": {
     "name": "Igor Ganapolsky",
     "email": "ig5973700@gmail.com"
@@ -13,7 +13,7 @@
         "source": "npm",
         "package": "thumbgate"
       },
-      "version": "1.17.0",
+      "version": "1.18.0",
       "author": {
         "name": "Igor Ganapolsky"
       },

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "thumbgate",
   "description": "Type 👍 or 👎 on any agent action. ThumbGate captures it, distills a lesson, and blocks the pattern from repeating. One thumbs-down = the agent physically cannot make that mistake again. 33 pre-action checks, budget enforcement, self-protection, and NIST/SOC2 compliance tags.",
-  "version": "1.17.0",
+  "version": "1.18.0",
   "author": {
     "name": "Igor Ganapolsky"
   },

package/.well-known/mcp/server-card.json

@@ -1,6 +1,6 @@
 {
   "name": "thumbgate",
-  "version": "1.17.0",
+  "version": "1.18.0",
   "description": "ThumbGate — 👍👎 feedback that teaches your AI agent. Thumbs down a mistake, it never happens again.",
   "homepage": "https://thumbgate-production.up.railway.app",
   "transport": "stdio",

package/adapters/claude/.mcp.json

@@ -2,13 +2,13 @@
   "mcpServers": {
     "thumbgate": {
       "command": "npx",
-      "args": ["--yes", "--package", "thumbgate@1.17.0", "thumbgate", "serve"]
+      "args": ["--yes", "--package", "thumbgate@1.18.0", "thumbgate", "serve"]
     }
   },
   "hooks": {
     "preToolUse": {
       "command": "npx",
-      "args": ["--yes", "--package", "thumbgate@1.17.0", "thumbgate", "gate-check"]
+      "args": ["--yes", "--package", "thumbgate@1.18.0", "thumbgate", "gate-check"]
     }
   }
 }

package/adapters/mcp/server-stdio.js

@@ -216,7 +216,7 @@ const {
   finalizeSession: finalizeFeedbackSession,
 } = require('../../scripts/feedback-session');
 
-const SERVER_INFO = { name: 'thumbgate-mcp', version: '1.17.0' };
+const SERVER_INFO = { name: 'thumbgate-mcp', version: '1.18.0' };
 const COMMERCE_CATEGORIES = [
   'product_recommendation',
   'brand_compliance',

package/adapters/opencode/opencode.json

@@ -7,7 +7,7 @@
         "npx",
         "--yes",
         "--package",
-        "thumbgate@1.17.0",
+        "thumbgate@1.18.0",
         "thumbgate",
         "serve"
       ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thumbgate",
-  "version": "1.17.0",
+  "version": "1.18.0",
   "description": "ThumbGate self-improving agent governance: thumbs-up/down turns every mistake into a prevention rule and blocks repeat patterns. 33 pre-action checks, budget enforcement, and self-protection for Claude Code, Cursor, Codex, Gemini CLI, and Amp.",
   "homepage": "https://thumbgate-production.up.railway.app",
   "repository": {
@@ -110,6 +110,7 @@
     "scripts/feedback-loop.js",
     "scripts/feedback-paths.js",
     "scripts/feedback-quality.js",
+    "scripts/feedback_quality_eval.py",
     "scripts/feedback-schema.js",
     "scripts/feedback-session.js",
     "scripts/feedback-to-rules.js",
@@ -346,6 +347,7 @@
     "test:telemetry-tracked-link-slug": "node --test tests/telemetry-tracked-link-slug.test.js",
     "test:prompt-eval": "node --test tests/prompt-eval.test.js",
     "eval:feedback": "node scripts/prompt-eval.js --from-feedback",
+    "eval:feedback-quality": "python3 scripts/feedback_quality_eval.py",
     "test:decision-trace": "node --test tests/decision-trace.test.js",
     "test:feedback-fallback": "node --test tests/feedback-fallback.test.js",
     "test:metaclaw": "node --test tests/metaclaw-features.test.js",
@@ -406,7 +408,7 @@
     "test:e2e": "node --test tests/e2e-pipeline.test.js tests/e2e-product-flows.test.js tests/e2e-coverage-contract.test.js",
     "test:rlaif": "node --test tests/rlaif-self-audit.test.js tests/dpo-optimizer.test.js tests/meta-policy.test.js tests/agent-reward-model.test.js",
     "test:attribution": "node --test tests/feedback-attribution.test.js tests/hybrid-feedback-context.test.js",
-    "test:quality": "node --test tests/validate-feedback.test.js",
+    "test:quality": "node --test tests/validate-feedback.test.js tests/feedback-quality-eval-python.test.js",
     "test:intelligence": "node --test tests/intelligence.test.js",
     "test:training-export": "node --test tests/training-export.test.js tests/databricks-export.test.js",
     "test:deployment": "node --test tests/deployment.test.js tests/deploy-policy.test.js tests/publish-decision.test.js tests/changeset-check.test.js tests/release-notes.test.js tests/sonarcloud-workflow.test.js tests/package-boundary.test.js tests/public-package-boundary.test.js tests/revenue-observability-workflow.test.js",
@@ -676,7 +678,7 @@
   "dependencies": {
     "@anthropic-ai/sdk": "0.92.0",
     "@google/genai": "1.49.0",
-    "@huggingface/transformers": "^4.1.0",
+    "@huggingface/transformers": "^4.2.0",
     "@lancedb/lancedb": "^0.27.2",
     "apache-arrow": "^18.1.0",
     "better-sqlite3": "^12.9.0",
@@ -692,7 +694,7 @@
   },
   "mcpName": "io.github.IgorGanapolsky/thumbgate",
   "devDependencies": {
-    "@changesets/changelog-github": "^0.6.0",
+    "@changesets/changelog-github": "^0.7.0",
     "@changesets/cli": "^2.31.0",
     "c8": "^11.0.0",
     "undici": "^8.2.0"

package/public/index.html

@@ -19,7 +19,7 @@ __GOOGLE_SITE_VERIFICATION_META__
 <meta property="og:image" content="https://thumbgate-production.up.railway.app/og.png">
 <meta name="twitter:card" content="summary_large_image">
 <meta name="twitter:image" content="https://thumbgate-production.up.railway.app/og.png">
-<meta name="thumbgate-version" content="1.17.0">
+<meta name="thumbgate-version" content="1.18.0">
 <meta name="keywords" content="ThumbGate, thumbgate, AI agent orchestration, AI experience orchestration, agent enforcement layer, save LLM tokens, reduce Claude API cost, reduce OpenAI cost, AI agent token savings, prevent LLM retries, prevent hallucination retries, stop AI token waste, pre-action checks, agent governance, Claude Code, Cursor, Codex, Gemini, Amp, Cline, OpenCode, workflow hardening, context engineering, AI authenticity, brand authenticity AI">
 <link rel="apple-touch-icon" href="/apple-touch-icon.png">
 
@@ -1231,26 +1231,26 @@ __GA_BOOTSTRAP__
         <a href="https://www.npmjs.com/package/thumbgate" target="_blank" rel="noopener" class="btn-free">Install Free</a>
       </div>
       <div class="price-card pro" data-price-dollars="19">
-        <div class="tier">Solo Pro</div>
+        <div class="tier">Pro</div>
         <div class="price">$19<span style="font-size:16px;color:var(--text-dim)">/mo</span></div>
-        <div class="price-sub">For builders who want proof, exports, and unlimited local learning.</div>
+        <div class="price-sub">Stop paying tokens to re-correct the same agent mistake across sessions.</div>
         <ul>
-          <li>Unlimited feedback captures and prevention rules</li>
-          <li>Lesson recall and search across sessions</li>
-          <li><a href="/dashboard#insights" style="color:var(--cyan);text-decoration:underline;">Visual check debugger</a> for every blocked action and the check that fired</li>
-          <li>Auto-connect so supported agents appear automatically after setup</li>
-          <li><a href="/dashboard#export" style="color:var(--cyan);text-decoration:underline;">DPO training data export</a> with ready-to-use preference pairs for fine-tuning</li>
-          <li>Personal local dashboard for the individual operator</li>
-          <li>Model Hardening Advisor plus HuggingFace dataset export</li>
-          <li>Review-ready workflow support and proof-ready lesson bundles</li>
-          <li>Team lesson export/import for handoff or migration</li>
+          <li><strong>Block every repeat mistake</strong> — unlimited feedback captures and prevention rules (Free caps at 5 active rules)</li>
+          <li><strong>Never re-explain a correction</strong> — lesson recall and search across sessions on every agent surface</li>
+          <li><strong>See exactly which rule fired</strong> — <a href="/dashboard#insights" style="color:var(--cyan);text-decoration:underline;">Visual check debugger</a> for every blocked action and the check that fired</li>
+          <li><strong>One install, every agent</strong> — Auto-connect so supported agents appear automatically after setup (Claude Code, Cursor, Codex, Gemini, Amp, Cline, OpenCode)</li>
+          <li><strong>Fine-tune your local model</strong> on what your team actually wants — <a href="/dashboard#export" style="color:var(--cyan);text-decoration:underline;">DPO training data export</a> with ready-to-use preference pairs for fine-tuning</li>
+          <li><strong>Audit-ready enforcement proof</strong> — Personal local dashboard for the individual operator with auditable block history</li>
+          <li><strong>Ship hardened agents to production</strong> — Model Hardening Advisor plus HuggingFace dataset export</li>
+          <li><strong>Hand a PR with proof</strong> — Review-ready workflow support and proof-ready lesson bundles a reviewer can verify in 30 seconds</li>
+          <li><strong>Hand off without re-onboarding</strong> — Team lesson export/import for handoff or migration</li>
         </ul>
         <div style="margin:12px 0 16px;padding:12px;border:1px solid rgba(34,211,238,0.25);border-radius:8px;background:rgba(34,211,238,0.06);">
           <div style="font-size:12px;color:var(--text-muted);margin-bottom:4px;">What your Pro dashboard looks like</div>
           <div style="font-family:var(--mono);font-size:12px;color:var(--cyan);line-height:1.6;">checks: 36 active<br>feedback: unlimited<br>exports: DPO + lessons</div>
         </div>
         <div style="font-size:11px;letter-spacing:0.08em;text-transform:uppercase;color:var(--cyan);font-weight:800;margin-bottom:8px;">PAY-NOW PRO</div>
-        <a href="/checkout/pro?confirm=1&utm_source=pricing&utm_medium=cta&utm_campaign=v2_landing&utm_content=pricing_pro" id="pro-checkout-link" class="btn-pro" onclick="handleProCheckout();return false;" style="display:block;width:100%;text-align:center;padding:12px;font-size:15px;">Upgrade to Pro — $19/mo</a>
+        <a href="/checkout/pro?utm_source=pricing&utm_medium=cta&utm_campaign=v2_landing&utm_content=pricing_pro&plan_id=pro" id="pro-checkout-link" class="btn-pro" onclick="handleProCheckout();return false;" style="display:block;width:100%;text-align:center;padding:12px;font-size:15px;">Upgrade to Pro — $19/mo</a>
         <p style="font-size:11px;color:var(--text-muted);margin-top:8px;text-align:center;">Billed today · cancel anytime.</p>
         <input type="email" id="pro-email" data-buyer-email placeholder="you@company.com" style="margin-top:10px;width:100%;padding:10px 12px;border:1px solid var(--border);border-radius:8px;background:var(--bg-raised);color:var(--text);font-size:14px;">
       </div>
@@ -1267,8 +1267,9 @@ __GA_BOOTSTRAP__
           <li>Workflow hardening sprint intake for approval boundaries and rollback safety</li>
           <li>Email support during pilot rollout</li>
         </ul>
-        <a href="#workflow-sprint-intake" class="btn-team" style="display:block;text-align:center;">Start Workflow Hardening Sprint</a>
-        <p style="font-size:11px;color:var(--text-muted);margin-top:8px;text-align:center;">No self-serve trial. Team is $49/seat/mo with a 3-seat minimum and starts with the Workflow Hardening Sprint intake, not a self-serve trial.</p>
+        <a href="/checkout/pro?plan_id=team&amp;seat_count=3&amp;confirm=1&amp;utm_source=website&amp;utm_medium=pricing&amp;utm_campaign=team_self_serve&amp;cta_id=pricing_team_self_serve&amp;cta_placement=pricing&amp;landing_path=%2F" onclick="try{posthog.capture('team_self_serve_click',{cta:'team_self_serve',seats:3,price:147})}catch(_){};sendFirstPartyTelemetry('team_self_serve_checkout_started',{ctaId:'pricing_team_self_serve',ctaPlacement:'pricing',planId:'team',seatCount:3,price:147});sendGa4Event('begin_checkout',{currency:'USD',value:147,items:[{item_id:'team_monthly',item_name:'ThumbGate Team (3 seats)',quantity:3}]});" class="btn-team" style="display:block;text-align:center;">Start 3-seat Team — $147/mo</a>
+        <a href="#workflow-sprint-intake" style="display:block;text-align:center;margin-top:8px;font-size:13px;color:var(--text-dim);text-decoration:none;">Or qualify first via Workflow Hardening Sprint intake →</a>
+        <p style="font-size:11px;color:var(--text-muted);margin-top:8px;text-align:center;">Team is $49/seat/mo with a 3-seat minimum. Self-serve checkout starts you at $147/mo for 3 seats; add more seats from the dashboard. Prefer to qualify the workflow before paying? Start with the intake.</p>
       </div>
     </div>
     <p style="text-align:center;color:var(--text-muted);font-size:13px;margin:40px 0;">Need a custom diagnostic, sprint, or setup? <a href="#workflow-sprint-intake" style="color:var(--cyan);text-decoration:none;">Send workflow first →</a></p>
@@ -1464,7 +1465,7 @@ __GA_BOOTSTRAP__
       <a href="https://www.linkedin.com/in/igorganapolsky" target="_blank" rel="noopener">LinkedIn</a>
       <a href="/blog">Blog</a>
     </div>
-    <span class="footer-copy">© 2026 ThumbGate · MIT License · npm v1.17.0</span>
+    <span class="footer-copy">© 2026 ThumbGate · MIT License · npm v1.18.0</span>
   </div>
 </footer>
 

package/public/numbers.html

@@ -25,7 +25,7 @@
   "alternateName": "thumbgate",
   "applicationCategory": "DeveloperApplication",
   "operatingSystem": "Cross-platform, Node.js >=18.18.0",
-  "softwareVersion": "1.17.0",
+  "softwareVersion": "1.18.0",
   "url": "https://thumbgate-production.up.railway.app/numbers",
   "dateModified": "2026-05-07",
   "creator": {
@@ -202,7 +202,7 @@
 <main class="container">
   <h1>The Numbers</h1>
   <p class="subtitle">Generated first-party operational snapshot from the ThumbGate runtime. This is not customer traction, install volume, revenue, or proof that a configured gate has fired.</p>
-  <div class="freshness">Updated: 2026-05-07 · Version 1.17.0</div>
+  <div class="freshness">Updated: 2026-05-07 · Version 1.18.0</div>
   <div class="truth-note"><strong>Read this first:</strong> configured checks are inventory. Recorded blocks and warnings are usage evidence. This snapshot currently reports 0 recorded hard-block event(s) and 0 recorded warning event(s).</div>
 
   <h2>Gate enforcement</h2>

package/scripts/auto-promote-gates.js

@@ -6,7 +6,10 @@ const path = require('path');
 const { resolveFeedbackDir } = require('./feedback-paths');
 
 const MAX_AUTO_GATES = 10;
-const WARN_THRESHOLD = 2; // 2+ repeated failures surface a warning gate
+// 1+ failure auto-promotes to a warning gate. Cold buyers expect "one 👎 → blocked next time"
+// — a 2-capture threshold made first-capture invisible and broke the activation loop. Block
+// escalation still requires 3 captures (BLOCK_THRESHOLD) so noise doesn't auto-hard-block.
+const WARN_THRESHOLD = 1;
 const BLOCK_THRESHOLD = 3; // 3+ repeated failures hard-block the action
 const WINDOW_DAYS = 30;
 

package/scripts/feedback-to-rules.js

@@ -32,7 +32,17 @@ function normalize(ctx) {
   return (ctx || '').replace(/\/Users\/[^\s/]+/g, '~').replace(/:[0-9]+/g, '').toLowerCase().trim();
 }
 
-const HIGH_RISK_TAGS = new Set(['git-workflow', 'scope-control', 'trust-breach', 'execution-gap', 'regression', 'security']);
+// HIGH_RISK_TAGS triggers single-capture promotion (count >= 1 && hasHighRisk).
+// Tags here MUST overlap with what inferSemanticTags() actually emits (see scripts/feedback-loop.js)
+// — otherwise cold buyers' first 👎 stays a lesson and never becomes a gate.
+const HIGH_RISK_TAGS = new Set([
+  // Original semantic-category labels
+  'git-workflow', 'scope-control', 'trust-breach', 'execution-gap', 'regression', 'security',
+  // Tags inferSemanticTags() emits for destructive / irreversible operations
+  'destructive', 'force-push', 'delete', 'drop', 'force-overwrite',
+  'production', 'database', 'payment', 'credentials', 'secrets',
+  'rm-rf', 'reset-hard', 'truncate', 'data-loss',
+]);
 function analyze(entries) {
   let positiveCount = 0, negativeCount = 0;
   const categories = {};

package/scripts/feedback_quality_eval.py

@@ -0,0 +1,725 @@
+#!/usr/bin/env python3
+"""
+Offline feedback quality evaluation for ThumbGate.
+
+This is intentionally stdlib-only. It turns feedback-log.jsonl into a small
+quality report that answers: where are repeated failures clustering, how stable
+is the signal, and do we have enough labeled gate decisions to compute true
+precision/recall yet?
+"""
+
+import argparse
+import json
+import math
+import os
+import re
+import sqlite3
+from collections import Counter, defaultdict
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, Iterable, List, Optional, Tuple
+
+
+PROJECT_ROOT = Path(__file__).parent.parent
+
+DEFAULT_CATEGORIES = {
+    "code_edit": {
+        "keywords": ["edit", "write", "implement", "refactor", "fix", "update", "create file"],
+        "tools": ["edit", "write", "multiedit"],
+    },
+    "git": {
+        "keywords": ["commit", "push", "branch", "merge", "pr", "pull request", "rebase", "cherry-pick"],
+        "tools": ["bash", "git"],
+    },
+    "testing": {
+        "keywords": ["test", "jest", "coverage", "verify", "verification", "spec", "mock", "assert"],
+        "tools": [],
+    },
+    "review": {
+        "keywords": ["review", "pr comment", "resolve", "thread", "feedback"],
+        "tools": [],
+    },
+    "search": {
+        "keywords": ["search", "find", "grep", "glob", "explore", "where is", "look for", "rg"],
+        "tools": ["grep", "glob", "read", "rg"],
+    },
+    "security": {
+        "keywords": ["security", "secret", "credential", "token", "auth", "injection", "xss"],
+        "tools": [],
+    },
+    "debugging": {
+        "keywords": ["debug", "error", "crash", "stack trace", "log", "diagnose", "investigate"],
+        "tools": [],
+    },
+}
+
+
+def resolve_feedback_dir() -> Path:
+    env_dir = os.environ.get("THUMBGATE_FEEDBACK_DIR")
+    if env_dir:
+        return Path(env_dir)
+
+    local_thumbgate = PROJECT_ROOT / ".thumbgate"
+    if local_thumbgate.exists():
+        return local_thumbgate
+
+    local_legacy = PROJECT_ROOT / ".claude" / "memory" / "feedback"
+    if local_legacy.exists():
+        return local_legacy
+
+    return Path.home() / ".thumbgate" / "projects" / PROJECT_ROOT.name
+
+
+def read_jsonl(path: Path) -> Tuple[List[Dict[str, Any]], int]:
+    rows: List[Dict[str, Any]] = []
+    invalid = 0
+    if not path.exists():
+        return rows, invalid
+
+    with path.open("r", encoding="utf-8") as handle:
+        for raw in handle:
+            line = raw.strip()
+            if not line:
+                continue
+            try:
+                parsed = json.loads(line)
+            except json.JSONDecodeError:
+                invalid += 1
+                continue
+            if isinstance(parsed, dict):
+                rows.append(parsed)
+            else:
+                invalid += 1
+    return rows, invalid
+
+
+def load_sqlite_lessons(db_path: Optional[Path]) -> Dict[str, Any]:
+    if not db_path:
+        return {
+            "available": False,
+            "path": None,
+            "totalLessons": 0,
+            "bySignal": {},
+            "byDomain": {},
+            "sourceFeedbackIds": [],
+            "error": None,
+        }
+    if not db_path.exists():
+        return {
+            "available": False,
+            "path": str(db_path),
+            "totalLessons": 0,
+            "bySignal": {},
+            "byDomain": {},
+            "sourceFeedbackIds": [],
+            "error": "SQLite lesson DB does not exist.",
+        }
+
+    try:
+        connection = sqlite3.connect(f"file:{db_path}?mode=ro", uri=True)
+        connection.row_factory = sqlite3.Row
+        try:
+            table_exists = connection.execute(
+                "SELECT name FROM sqlite_master WHERE type='table' AND name='lessons'"
+            ).fetchone()
+            if not table_exists:
+                return {
+                    "available": False,
+                    "path": str(db_path),
+                    "totalLessons": 0,
+                    "bySignal": {},
+                    "byDomain": {},
+                    "sourceFeedbackIds": [],
+                    "error": "SQLite DB does not contain a lessons table.",
+                }
+
+            rows = connection.execute(
+                "SELECT id, signal, domain, sourceFeedbackId FROM lessons WHERE pruned = 0"
+            ).fetchall()
+        finally:
+            connection.close()
+    except sqlite3.Error as exc:
+        return {
+            "available": False,
+            "path": str(db_path),
+            "totalLessons": 0,
+            "bySignal": {},
+            "byDomain": {},
+            "sourceFeedbackIds": [],
+            "error": str(exc),
+        }
+
+    by_signal = Counter(str(row["signal"] or "unknown") for row in rows)
+    by_domain = Counter(str(row["domain"] or "unknown") for row in rows)
+    source_ids = sorted({
+        str(row["sourceFeedbackId"])
+        for row in rows
+        if row["sourceFeedbackId"]
+    })
+    return {
+        "available": True,
+        "path": str(db_path),
+        "totalLessons": len(rows),
+        "bySignal": dict(sorted(by_signal.items())),
+        "byDomain": dict(sorted(by_domain.items())),
+        "sourceFeedbackIds": source_ids,
+        "error": None,
+    }
+
+
+def normalize_signal(entry: Dict[str, Any]) -> Optional[str]:
+    raw = str(entry.get("signal") or entry.get("feedback") or "").strip().lower()
+    if raw in {"positive", "up", "thumbsup", "thumbs_up", "👍"}:
+        return "positive"
+    if raw in {"negative", "down", "thumbsdown", "thumbs_down", "👎"}:
+        return "negative"
+
+    reward = entry.get("reward")
+    if isinstance(reward, (int, float)):
+        if reward > 0:
+            return "positive"
+        if reward < 0:
+            return "negative"
+    return None
+
+
+def normalize_text(*values: Any) -> str:
+    parts = []
+    for value in values:
+        if value is None:
+            continue
+        if isinstance(value, list):
+            parts.extend(str(item) for item in value)
+        elif isinstance(value, dict):
+            parts.append(json.dumps(value, sort_keys=True))
+        else:
+            parts.append(str(value))
+    return " ".join(parts).lower()
+
+
+def contains_keyword(text: str, keyword: str) -> bool:
+    normalized_keyword = keyword.lower().strip()
+    if not normalized_keyword:
+        return False
+    if len(normalized_keyword) <= 3 or re.fullmatch(r"[a-z0-9_+-]+", normalized_keyword):
+        return re.search(rf"(?<![a-z0-9_+-]){re.escape(normalized_keyword)}(?![a-z0-9_+-])", text) is not None
+    return normalized_keyword in text
+
+
+def classify_entry(entry: Dict[str, Any]) -> List[str]:
+    tags = entry.get("tags") if isinstance(entry.get("tags"), list) else []
+    tool = entry.get("toolName") or entry.get("tool_name") or entry.get("last_tool")
+    text = normalize_text(
+        entry.get("context"),
+        entry.get("whatWentWrong"),
+        entry.get("whatToChange"),
+        entry.get("whatWorked"),
+        entry.get("actionReason"),
+        entry.get("failureType"),
+        tags,
+    )
+    tool_text = normalize_text(tool)
+
+    matched = []
+    for category, config in DEFAULT_CATEGORIES.items():
+        keyword_match = any(contains_keyword(text, keyword) for keyword in config["keywords"])
+        tool_match = any(contains_keyword(tool_text, tool_name) for tool_name in config["tools"])
+        if keyword_match or tool_match:
+            matched.append(category)
+
+    if not matched:
+        domain = entry.get("richContext", {}).get("domain") if isinstance(entry.get("richContext"), dict) else None
+        if isinstance(domain, str) and domain:
+            matched.append(domain)
+
+    return matched or ["uncategorized"]
+
+
+def parse_timestamp(value: Any) -> Optional[datetime]:
+    if not isinstance(value, str) or not value:
+        return None
+    try:
+        normalized = value.replace("Z", "+00:00")
+        parsed = datetime.fromisoformat(normalized)
+        if parsed.tzinfo is None:
+            parsed = parsed.replace(tzinfo=timezone.utc)
+        return parsed
+    except ValueError:
+        return None
+
+
+def rate(numerator: int, denominator: int) -> float:
+    return round(numerator / denominator, 4) if denominator else 0.0
+
+
+def wilson_lower_bound(positive: int, total: int, z: float = 1.96) -> float:
+    if total <= 0:
+        return 0.0
+    p = positive / total
+    denom = 1 + z * z / total
+    centre = p + z * z / (2 * total)
+    spread = z * math.sqrt((p * (1 - p) + z * z / (4 * total)) / total)
+    return round((centre - spread) / denom, 4)
+
+
+def summarize_bucket(name: str, values: Iterable[str], signals: List[str], min_support: int) -> List[Dict[str, Any]]:
+    counts: Dict[str, Counter] = defaultdict(Counter)
+    for bucket_value, signal in zip(values, signals):
+        counts[bucket_value][signal] += 1
+
+    rows = []
+    for bucket_value, counter in counts.items():
+        positive = counter["positive"]
+        negative = counter["negative"]
+        total = positive + negative
+        if total < min_support:
+            continue
+        rows.append({
+            name: bucket_value,
+            "support": total,
+            "positive": positive,
+            "negative": negative,
+            "positiveRate": rate(positive, total),
+            "negativeRate": rate(negative, total),
+            "wilsonPositiveLower": wilson_lower_bound(positive, total),
+        })
+
+    return sorted(rows, key=lambda row: (-row["negativeRate"], -row["support"], row[name]))
+
+
+def explicit_gate_label(entry: Dict[str, Any]) -> Tuple[Optional[str], Optional[str]]:
+    """Return expected/actual labels when the log carries explicit gate labels.
+
+    expected: harmful/safe based on feedback signal.
+    actual: blocked/allowed from gate decision fields.
+    """
+    signal = normalize_signal(entry)
+    if not signal:
+        return None, None
+
+    expected = "harmful" if signal == "negative" else "safe"
+
+    for key in ("gateDecision", "decision", "outcome", "status"):
+        value = str(entry.get(key) or "").lower()
+        if value in {"block", "blocked", "deny", "denied", "rejected"}:
+            return expected, "blocked"
+        if value in {"allow", "allowed", "pass", "passed", "accepted"}:
+            return expected, "allowed"
+
+    if isinstance(entry.get("allowed"), bool):
+        return expected, "allowed" if entry["allowed"] else "blocked"
+    if isinstance(entry.get("blocked"), bool):
+        return expected, "blocked" if entry["blocked"] else "allowed"
+    if entry.get("actionType") == "no-action":
+        return expected, "blocked"
+
+    return expected, None
+
+
+def compute_sqlite_metrics(entries: List[Dict[str, Any]], sqlite_lessons: Dict[str, Any]) -> Dict[str, Any]:
+    if not sqlite_lessons.get("available"):
+        return {
+            "available": False,
+            "path": sqlite_lessons.get("path"),
+            "totalLessons": 0,
+            "feedbackLessonCoverage": 0.0,
+            "negativeLessonCoverage": 0.0,
+            "bySignal": {},
+            "byDomain": {},
+            "error": sqlite_lessons.get("error"),
+        }
+
+    feedback_ids = {str(entry.get("id")) for entry in entries if entry.get("id")}
+    negative_ids = {
+        str(entry.get("id"))
+        for entry in entries
+        if entry.get("id") and normalize_signal(entry) == "negative"
+    }
+    lesson_feedback_ids = set(sqlite_lessons.get("sourceFeedbackIds") or [])
+
+    return {
+        "available": True,
+        "path": sqlite_lessons.get("path"),
+        "totalLessons": sqlite_lessons.get("totalLessons", 0),
+        "feedbackLessonCoverage": rate(len(feedback_ids & lesson_feedback_ids), len(feedback_ids)),
+        "negativeLessonCoverage": rate(len(negative_ids & lesson_feedback_ids), len(negative_ids)),
+        "bySignal": sqlite_lessons.get("bySignal") or {},
+        "byDomain": sqlite_lessons.get("byDomain") or {},
+        "error": None,
+    }
+
+
+def retrieval_score(row: Dict[str, Any]) -> Optional[float]:
+    for key in ("score", "similarity", "distanceScore", "topSimilarity"):
+        value = row.get(key)
+        if isinstance(value, (int, float)) and math.isfinite(value):
+            return float(value)
+        try:
+            return float(value)
+        except (TypeError, ValueError):
+            continue
+    return None
+
+
+def feedback_id_for_retrieval(row: Dict[str, Any]) -> Optional[str]:
+    for key in ("feedbackId", "sourceFeedbackId", "queryFeedbackId", "id"):
+        value = row.get(key)
+        if value:
+            return str(value)
+    return None
+
+
+def unavailable_retrieval_metrics() -> Dict[str, Any]:
+    return {
+        "available": False,
+        "rows": 0,
+        "queries": 0,
+        "averageTopScore": None,
+        "negativeNeighborRate": None,
+        "error": None,
+    }
+
+
+def bucket_retrieval_rows(retrieval_rows: List[Dict[str, Any]]) -> Dict[str, List[Dict[str, Any]]]:
+    by_feedback: Dict[str, List[Dict[str, Any]]] = defaultdict(list)
+    for row in retrieval_rows:
+        feedback_id = feedback_id_for_retrieval(row) or "unknown"
+        by_feedback[feedback_id].append(row)
+    return by_feedback
+
+
+def top_retrieval_scores(by_feedback: Dict[str, List[Dict[str, Any]]]) -> List[float]:
+    top_scores = []
+    for rows in by_feedback.values():
+        scores = [score for score in (retrieval_score(row) for row in rows) if score is not None]
+        if scores:
+            top_scores.append(max(scores))
+    return top_scores
+
+
+def retrieval_neighbor_summary(retrieval_rows: List[Dict[str, Any]]) -> Dict[str, int]:
+    summary = {"labeled": 0, "negative": 0}
+    for row in retrieval_rows:
+        neighbor_signal = normalize_signal({
+            "signal": row.get("matchedSignal") or row.get("neighborSignal") or row.get("signal")
+        })
+        if not neighbor_signal:
+            continue
+        summary["labeled"] += 1
+        if neighbor_signal == "negative":
+            summary["negative"] += 1
+    return summary
+
+
+def compute_retrieval_metrics(retrieval_rows: List[Dict[str, Any]]) -> Dict[str, Any]:
+    if not retrieval_rows:
+        return unavailable_retrieval_metrics()
+
+    by_feedback = bucket_retrieval_rows(retrieval_rows)
+    top_scores = top_retrieval_scores(by_feedback)
+    neighbor_summary = retrieval_neighbor_summary(retrieval_rows)
+    labeled_neighbors = neighbor_summary["labeled"]
+
+    return {
+        "available": True,
+        "rows": len(retrieval_rows),
+        "queries": len(by_feedback),
+        "averageTopScore": round(sum(top_scores) / len(top_scores), 4) if top_scores else None,
+        "negativeNeighborRate": rate(neighbor_summary["negative"], labeled_neighbors) if labeled_neighbors else None,
+        "error": None,
+    }
+
+
+GATE_OUTCOME_KEYS = {
+    ("harmful", "blocked"): "truePositiveBlocks",
+    ("safe", "allowed"): "trueNegativeAllows",
+    ("safe", "blocked"): "falsePositiveBlocks",
+    ("harmful", "allowed"): "falseNegativeAllows",
+}
+
+
+def initial_gate_counts() -> Dict[str, int]:
+    return {
+        "truePositiveBlocks": 0,
+        "trueNegativeAllows": 0,
+        "falsePositiveBlocks": 0,
+        "falseNegativeAllows": 0,
+        "unlabeledFeedback": 0,
+    }
+
+
+def count_gate_outcomes(entries: List[Dict[str, Any]]) -> Dict[str, int]:
+    counts = initial_gate_counts()
+
+    for entry in entries:
+        expected, actual = explicit_gate_label(entry)
+        if expected is None:
+            continue
+        if actual is None:
+            counts["unlabeledFeedback"] += 1
+            continue
+
+        count_key = GATE_OUTCOME_KEYS.get((expected, actual))
+        if count_key:
+            counts[count_key] += 1
+
+    return counts
+
+
+def compute_f1(precision: Optional[float], recall: Optional[float], labeled: int) -> Optional[float]:
+    if not labeled:
+        return None
+    if not precision or not recall:
+        return 0.0
+    return round((2 * precision * recall) / (precision + recall), 4)
+
+
+def compute_gate_metrics(entries: List[Dict[str, Any]]) -> Dict[str, Any]:
+    counts = count_gate_outcomes(entries)
+    tp = counts["truePositiveBlocks"]
+    tn = counts["trueNegativeAllows"]
+    fp = counts["falsePositiveBlocks"]
+    fn = counts["falseNegativeAllows"]
+
+    labeled = tp + tn + fp + fn
+    precision = rate(tp, tp + fp) if labeled else None
+    recall = rate(tp, tp + fn) if labeled else None
+    f1 = compute_f1(precision, recall, labeled)
+
+    return {
+        "available": labeled > 0,
+        "labeledDecisions": labeled,
+        "unlabeledFeedback": counts["unlabeledFeedback"],
+        "truePositiveBlocks": tp,
+        "trueNegativeAllows": tn,
+        "falsePositiveBlocks": fp,
+        "falseNegativeAllows": fn,
+        "precision": precision,
+        "recall": recall,
+        "f1": f1,
+        "note": None if labeled else "No explicit gate decision labels found; feedback quality metrics are available, but classifier precision/recall needs blocked/allowed labels.",
+    }
+
+
+def base_recommendations(report: Dict[str, Any]) -> List[str]:
+    items = []
+    if report["usableEntries"] < 10:
+        items.append("Collect at least 10 usable feedback entries before making threshold changes.")
+    if not report["gateMetrics"]["available"]:
+        items.append("Start logging gate decisions as blocked/allowed so precision, recall, and false-positive rate can be computed.")
+    return items
+
+
+def storage_recommendations(report: Dict[str, Any]) -> List[str]:
+    items = []
+    sqlite_metrics = report.get("sqliteLessonMetrics") or {}
+    if sqlite_metrics.get("available") and sqlite_metrics.get("negativeLessonCoverage", 0) < 0.8:
+        items.append("Backfill SQLite lesson rows for negative feedback before treating SQL dashboards as complete eval evidence.")
+
+    retrieval_metrics = report.get("retrievalMetrics") or {}
+    if retrieval_metrics.get("available") and retrieval_metrics.get("negativeNeighborRate") is not None and retrieval_metrics["negativeNeighborRate"] >= 0.5:
+        items.append("Inspect LanceDB retrieval neighborhoods: most labeled neighbors are negative, which is a good candidate for repeated-failure clustering.")
+    return items
+
+
+def category_recommendations(report: Dict[str, Any]) -> List[str]:
+    items = []
+    weak_categories = [
+        row for row in report["categoryMetrics"]
+        if row["support"] >= report["minSupport"] and row["negativeRate"] >= 0.5
+    ]
+    if weak_categories:
+        top = weak_categories[0]
+        items.append(
+            f"Tighten prevention rules for {top['category']}: {top['negative']} negative signals across {top['support']} entries."
+        )
+    return items
+
+
+def tag_recommendations(report: Dict[str, Any]) -> List[str]:
+    volatile_tags = [
+        row for row in report["tagMetrics"]
+        if row["support"] >= report["minSupport"] and 0.35 <= row["positiveRate"] <= 0.65
+    ]
+    if not volatile_tags:
+        return []
+    return [
+        f"Review mixed-signal tag '{volatile_tags[0]['tag']}' before promoting broad rules; signal is not separable yet."
+    ]
+
+
+def build_recommendations(report: Dict[str, Any]) -> List[str]:
+    recommendations = []
+    recommendations.extend(base_recommendations(report))
+    recommendations.extend(storage_recommendations(report))
+    recommendations.extend(category_recommendations(report))
+    recommendations.extend(tag_recommendations(report))
+    if not recommendations:
+        recommendations.append("No immediate eval action required; keep collecting feedback and rerun this report after the next batch.")
+    return recommendations
+
+
+def evaluate_feedback(
+    entries: List[Dict[str, Any]],
+    invalid_entries: int = 0,
+    min_support: int = 2,
+    sqlite_lessons: Optional[Dict[str, Any]] = None,
+    retrieval_rows: Optional[List[Dict[str, Any]]] = None,
+) -> Dict[str, Any]:
+    usable = []
+    signals = []
+    category_values = []
+    tag_values = []
+    failure_values = []
+    timestamps = []
+
+    for entry in entries:
+        signal = normalize_signal(entry)
+        if signal not in {"positive", "negative"}:
+            continue
+        usable.append(entry)
+        signals.append(signal)
+        categories = classify_entry(entry)
+        category_values.append(categories[0])
+        tags = entry.get("tags") if isinstance(entry.get("tags"), list) else []
+        tag_values.append(str(tags[0]).strip().lower() if tags else "untagged")
+        failure_values.append(str(entry.get("failureType") or "unspecified").strip().lower())
+        parsed_ts = parse_timestamp(entry.get("timestamp"))
+        if parsed_ts:
+            timestamps.append(parsed_ts)
+
+    positive = signals.count("positive")
+    negative = signals.count("negative")
+    report = {
+        "generatedAt": datetime.now(timezone.utc).isoformat(),
+        "minSupport": min_support,
+        "totalEntries": len(entries),
+        "usableEntries": len(usable),
+        "invalidEntries": invalid_entries,
+        "positive": positive,
+        "negative": negative,
+        "positiveRate": rate(positive, len(usable)),
+        "negativeRate": rate(negative, len(usable)),
+        "firstTimestamp": min(timestamps).isoformat() if timestamps else None,
+        "lastTimestamp": max(timestamps).isoformat() if timestamps else None,
+        "categoryMetrics": summarize_bucket("category", category_values, signals, min_support),
+        "tagMetrics": summarize_bucket("tag", tag_values, signals, min_support),
+        "failureTypeMetrics": summarize_bucket("failureType", failure_values, signals, min_support),
+        "gateMetrics": compute_gate_metrics(usable),
+        "sqliteLessonMetrics": compute_sqlite_metrics(usable, sqlite_lessons or {"available": False, "error": None}),
+        "retrievalMetrics": compute_retrieval_metrics(retrieval_rows or []),
+    }
+    report["recommendations"] = build_recommendations(report)
+    return report
+
+
+def render_markdown(report: Dict[str, Any]) -> str:
+    lines = [
+        "# Feedback Quality Eval",
+        "",
+        f"- Generated: {report['generatedAt']}",
+        f"- Usable feedback: {report['usableEntries']} / {report['totalEntries']}",
+        f"- Positive rate: {report['positiveRate']}",
+        f"- Negative rate: {report['negativeRate']}",
+        "",
+        "## Gate Metrics",
+        "",
+    ]
+    gate = report["gateMetrics"]
+    if gate["available"]:
+        lines.extend([
+            f"- Labeled decisions: {gate['labeledDecisions']}",
+            f"- Precision: {gate['precision']}",
+            f"- Recall: {gate['recall']}",
+            f"- F1: {gate['f1']}",
+            f"- False positive blocks: {gate['falsePositiveBlocks']}",
+            f"- False negative allows: {gate['falseNegativeAllows']}",
+        ])
+    else:
+        lines.append(f"- {gate['note']}")
+
+    lines.extend(["", "## Highest-Risk Categories", ""])
+    if report["categoryMetrics"]:
+        lines.append("| Category | Support | Positive | Negative | Negative rate |")
+        lines.append("| --- | ---: | ---: | ---: | ---: |")
+        for row in report["categoryMetrics"][:8]:
+            lines.append(f"| {row['category']} | {row['support']} | {row['positive']} | {row['negative']} | {row['negativeRate']} |")
+    else:
+        lines.append("- Not enough category support yet.")
+
+    sqlite_metrics = report["sqliteLessonMetrics"]
+    lines.extend(["", "## SQLite Lesson Coverage", ""])
+    if sqlite_metrics["available"]:
+        lines.extend([
+            f"- Lessons: {sqlite_metrics['totalLessons']}",
+            f"- Feedback coverage: {sqlite_metrics['feedbackLessonCoverage']}",
+            f"- Negative feedback coverage: {sqlite_metrics['negativeLessonCoverage']}",
+        ])
+    else:
+        lines.append(f"- Not available{': ' + sqlite_metrics['error'] if sqlite_metrics.get('error') else ''}.")
+
+    retrieval_metrics = report["retrievalMetrics"]
+    lines.extend(["", "## LanceDB Retrieval Export", ""])
+    if retrieval_metrics["available"]:
+        lines.extend([
+            f"- Rows: {retrieval_metrics['rows']}",
+            f"- Queries: {retrieval_metrics['queries']}",
+            f"- Average top score: {retrieval_metrics['averageTopScore']}",
+            f"- Negative neighbor rate: {retrieval_metrics['negativeNeighborRate']}",
+        ])
+    else:
+        lines.append("- Not available. Export retrieval rows to JSONL to evaluate semantic recall quality.")
+
+    lines.extend(["", "## Recommendations", ""])
+    lines.extend(f"- {item}" for item in report["recommendations"])
+    lines.append("")
+    return "\n".join(lines)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Evaluate ThumbGate feedback quality from feedback-log.jsonl.")
+    parser.add_argument("--feedback-log", help="Path to feedback-log.jsonl. Defaults to the resolved ThumbGate feedback dir.")
+    parser.add_argument("--feedback-dir", help="Directory containing feedback-log.jsonl.")
+    parser.add_argument("--lesson-db", help="Path to lessons.sqlite for SQL lesson coverage metrics.")
+    parser.add_argument("--retrieval-log", help="JSONL export of LanceDB retrieval rows for semantic recall metrics.")
+    parser.add_argument("--min-support", type=int, default=2, help="Minimum bucket support for category/tag metrics.")
+    parser.add_argument("--json", action="store_true", help="Print JSON instead of Markdown.")
+    parser.add_argument("--write-report", help="Write the rendered report to a file.")
+    return parser.parse_args()
+
+
+def main() -> int:
+    args = parse_args()
+    feedback_log = Path(args.feedback_log) if args.feedback_log else None
+    if feedback_log is None:
+        feedback_dir = Path(args.feedback_dir) if args.feedback_dir else resolve_feedback_dir()
+        feedback_log = feedback_dir / "feedback-log.jsonl"
+
+    entries, invalid = read_jsonl(feedback_log)
+    lesson_db = Path(args.lesson_db) if args.lesson_db else None
+    retrieval_log = Path(args.retrieval_log) if args.retrieval_log else None
+    retrieval_rows, retrieval_invalid = read_jsonl(retrieval_log) if retrieval_log else ([], 0)
+    sqlite_lessons = load_sqlite_lessons(lesson_db)
+    report = evaluate_feedback(
+        entries,
+        invalid_entries=invalid,
+        min_support=max(args.min_support, 1),
+        sqlite_lessons=sqlite_lessons,
+        retrieval_rows=retrieval_rows,
+    )
+    report["feedbackLog"] = str(feedback_log)
+    report["lessonDb"] = str(lesson_db) if lesson_db else None
+    report["retrievalLog"] = str(retrieval_log) if retrieval_log else None
+    report["invalidRetrievalRows"] = retrieval_invalid
+
+    output = json.dumps(report, indent=2, sort_keys=True) if args.json else render_markdown(report)
+    if args.write_report:
+        out_path = Path(args.write_report)
+        out_path.parent.mkdir(parents=True, exist_ok=True)
+        out_path.write_text(output + ("\n" if not output.endswith("\n") else ""), encoding="utf-8")
+    print(output)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/src/api/server.js

@@ -403,6 +403,27 @@ const TRACKED_LINK_TARGETS = Object.freeze({
     },
     allowCustomerEmail: true,
   },
+  // 2026-05-12: Aiventyx marketplace listing routes its Teams clicks through
+  // /go/teams (best-performing listing at ~62% CTR). Without this slug the
+  // server returned 404 + "Tracked link not found". Every Aiventyx Teams
+  // click between the URL swap and this deploy landed on that error page.
+  // Destination: 3-seat Team self-serve Stripe checkout (the path I shipped
+  // in PR #1877 — plan_id=team + seat_count=3 = $147/mo entry).
+  teams: {
+    path: '/checkout/pro',
+    ctaId: 'go_teams',
+    ctaPlacement: 'link_router',
+    eventType: 'cta_click',
+    defaults: {
+      utm_source: 'website',
+      utm_medium: 'link_router',
+      utm_campaign: 'team_self_serve',
+      plan_id: 'team',
+      seat_count: '3',
+      billing_cycle: 'monthly',
+    },
+    allowCustomerEmail: true,
+  },
   install: {
     path: '/guide',
     ctaId: 'go_install',
@@ -1511,7 +1532,7 @@ function renderCheckoutIntentPage({
   const teardownAction = safeWorkflowTeardownCheckoutHref
     ? `<a data-i="workflow_teardown_checkout" href="${safeWorkflowTeardownCheckoutHref}">Pay $99 teardown</a>`
     : '';
-  return `<!doctype html><html lang="en"><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><style>body{background:#0a0a0a;color:#eee;font-family:system-ui,sans-serif}div{max-width:560px;margin:12vh auto}a{display:block;margin:10px 0;padding:12px;border:1px solid #374151;color:inherit;text-align:center}.primary{background:#22d3ee;color:#000}.high-ticket{border-color:#4ade80;color:#4ade80}</style><div><h1>Choose the right paid path.</h1><p>For one repeated workflow failure, start with the diagnostic or sprint. Use Pro only when you need the local self-serve dashboard.</p>${diagnosticAction.replace('<a ', '<a class="high-ticket" ')}${sprintAction.replace('<a ', '<a class="high-ticket" ')}<a class="primary" data-i="pro_checkout_confirmed" href="${safeConfirmHref}">Pay in Stripe</a>${teardownAction}${quickReadAction}${firstRuleAction}<a data-i="workflow_sprint_intake" href="${safeWorkflowIntakeHref}">Send workflow first</a><a data-i="team_paid_path" href="${safeTeamOptionsHref}">See options</a><p>Stripe checkout.</p><a href="/">Back</a></div><script>addEventListener('click',e=>{let a=e.target.closest('[data-i]');if(a&&navigator.sendBeacon)navigator.sendBeacon('/v1/telemetry/ping',new Blob([JSON.stringify({eventType:'checkout_interstitial_cta_clicked',clientType:'web',page:'/checkout/pro',ctaId:a.dataset.i,ctaPlacement:'checkout_interstitial'})],{type:'application/json'}))})</script>`;
+  return `<!doctype html><html lang="en"><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>Confirm — ThumbGate Pro</title><style>body{background:#0a0a0a;color:#eee;font-family:system-ui,-apple-system,sans-serif;line-height:1.5}main{max-width:520px;margin:8vh auto;padding:0 20px}.brand{display:flex;align-items:center;gap:10px;margin-bottom:24px;font-size:14px;color:#94a3b8}.brand-mark{width:24px;height:24px;background:#22d3ee;border-radius:6px;display:inline-block}h1{font-size:24px;margin:0 0 8px;color:#fff}.price{font-size:32px;font-weight:700;color:#22d3ee;margin:8px 0 4px}.price small{font-size:14px;color:#94a3b8;font-weight:400}p{color:#cbd5e1;margin:8px 0}a{display:block;text-decoration:none}a.primary{background:#22d3ee;color:#000;padding:16px;text-align:center;border-radius:8px;font-weight:700;font-size:16px;margin:20px 0 10px}a.secondary{border:1px solid #374151;color:#cbd5e1;padding:12px;text-align:center;border-radius:8px;margin:8px 0;font-size:14px}.trust{margin:24px 0;padding:16px;border:1px solid #1f2937;border-radius:8px;background:#0f172a}.trust-item{font-size:13px;color:#cbd5e1;padding:4px 0;display:flex;gap:8px}.trust-item::before{content:"✓";color:#22d3ee;font-weight:700}details{margin-top:32px;font-size:13px;color:#94a3b8}details summary{cursor:pointer;padding:8px 0}details a{border:1px solid #374151;color:#94a3b8;padding:10px;text-align:center;border-radius:6px;margin:6px 0;font-size:13px}.back{text-align:center;color:#64748b;font-size:12px;margin-top:24px}.back a{color:#64748b;display:inline}</style><main><div class="brand"><span class="brand-mark"></span><span>ThumbGate</span></div><h1>Start ThumbGate Pro</h1><div class="price">$19<small>/mo</small></div><p>Block every repeat AI-agent mistake. Local-first. MIT-licensed CLI included. Cancel anytime.</p><a class="primary" data-i="pro_checkout_confirmed" href="${safeConfirmHref}">Pay $19/mo with Stripe →</a><div class="trust"><div class="trust-item">6 paying customers, 18,000+ installs verified on npm</div><div class="trust-item">Cancel anytime — instant refund within 7 days</div><div class="trust-item">MIT open source · no vendor lock-in</div><div class="trust-item">Works with Claude Code, Cursor, Codex, Gemini, Amp, Cline, OpenCode</div></div><details><summary>Other paid paths (diagnostic, sprint, teardown, single-rule)</summary>${diagnosticAction.replace('<a ', '<a class="secondary" ')}${sprintAction.replace('<a ', '<a class="secondary" ')}${teardownAction.replace('<a ', '<a class="secondary" ')}${quickReadAction.replace('<a ', '<a class="secondary" ')}${firstRuleAction.replace('<a ', '<a class="secondary" ')}<a class="secondary" data-i="workflow_sprint_intake" href="${safeWorkflowIntakeHref}">Send workflow first (intake)</a><a class="secondary" data-i="team_paid_path" href="${safeTeamOptionsHref}">See all options</a></details><p class="back"><a href="/">← Back to thumbgate.ai</a></p></main><script>addEventListener('click',e=>{let a=e.target.closest('[data-i]');if(a&&navigator.sendBeacon)navigator.sendBeacon('/v1/telemetry/ping',new Blob([JSON.stringify({eventType:'checkout_interstitial_cta_clicked',clientType:'web',page:'/checkout/pro',ctaId:a.dataset.i,ctaPlacement:'checkout_interstitial'})],{type:'application/json'}))})</script></html>`;
 }
 
 function buildCheckoutBootstrapBody(parsed, req, journeyState = resolveJourneyState(req, parsed)) {