thumbgate 1.27.19 → 1.28.0

package/adapters/policy-engine/thumbgate-policy-engine-adapter.js

@@ -0,0 +1,260 @@
+#!/usr/bin/env node
+'use strict';
+
+const { normalizeProviderAction } = require('../../scripts/provider-action-normalizer');
+
+const BLOCK_DECISIONS = new Set([
+  'block',
+  'blocked',
+  'deny',
+  'denied',
+  'disallow',
+  'disallowed',
+  'fail',
+  'failed',
+  'forbid',
+  'forbidden',
+  'reject',
+  'rejected',
+  'unsafe',
+  'violation',
+]);
+
+const REVIEW_DECISIONS = new Set([
+  'approval',
+  'approval-required',
+  'approval_required',
+  'approve',
+  'human-review',
+  'human_review',
+  'manual-review',
+  'manual_review',
+  'review',
+  'requires-approval',
+  'requires_approval',
+  'requires-review',
+  'requires_review',
+]);
+
+const ALLOW_DECISIONS = new Set([
+  'accept',
+  'accepted',
+  'allow',
+  'allowed',
+  'ok',
+  'pass',
+  'passed',
+  'permit',
+  'permitted',
+  'safe',
+]);
+
+function asObject(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function firstString(...values) {
+  for (const value of values) {
+    const text = String(value || '').trim();
+    if (text) return text;
+  }
+  return '';
+}
+
+function normalizeDecisionToken(value) {
+  return String(value || '')
+    .trim()
+    .toLowerCase()
+    .replace(/\s+/g, '-');
+}
+
+function normalizeEvidence(value) {
+  const direct = asArray(value.evidence);
+  const citations = asArray(value.citations);
+  const violations = asArray(value.violations);
+  const reasons = asArray(value.reasons);
+  const reasoning = asArray(value.reasoning);
+  const threatTypes = asArray(value.threat_types || value.threatTypes)
+    .map((threatType) => ({
+      code: String(threatType || '').trim(),
+      message: `Threat type: ${String(threatType || '').trim()}`,
+      source: 'guardian',
+      severity: firstString(value.threat_level, value.threatLevel),
+    }));
+  return [...direct, ...citations, ...violations, ...reasons, ...reasoning, ...threatTypes]
+    .map((entry) => {
+      if (typeof entry === 'string') return { text: entry };
+      const object = asObject(entry);
+      if (!Object.keys(object).length) return null;
+      return {
+        id: firstString(object.id, object.ruleId, object.rule_id, object.code),
+        text: firstString(object.text, object.reason, object.message, object.description, object.title),
+        source: firstString(object.source, object.provider, object.policy),
+        severity: firstString(object.severity, object.level),
+        raw: object,
+      };
+    })
+    .filter(Boolean);
+}
+
+function extractPolicyDecision(input = {}) {
+  const event = asObject(input);
+  for (const candidate of [
+    event.policyDecision,
+    event.policy_decision,
+    event.guardrailResult,
+    event.guardrail_result,
+    event.result,
+  ]) {
+    const object = asObject(candidate);
+    if (Object.keys(object).length) return object;
+  }
+  return event;
+}
+
+function classifyPolicyDecision(input = {}) {
+  const value = extractPolicyDecision(input);
+  const token = normalizeDecisionToken(firstString(
+    value.decision,
+    value.action,
+    value.status,
+    value.result,
+    value.verdict,
+    value.outcome,
+    value.effect,
+    value.recommended_action,
+    value.recommendedAction,
+  ));
+
+  if (
+    value.allowed === false
+    || value.is_safe === false
+    || value.isSafe === false
+    || value.accepted === false
+    || value.blocked === true
+    || value.denied === true
+    || BLOCK_DECISIONS.has(token)
+  ) {
+    return 'block';
+  }
+  if (
+    value.requiresApproval === true
+    || value.requires_approval === true
+    || value.reviewRequired === true
+    || value.review_required === true
+    || REVIEW_DECISIONS.has(token)
+  ) {
+    return 'approval_required';
+  }
+  if (
+    value.allowed === true
+    || value.is_safe === true
+    || value.isSafe === true
+    || value.accepted === true
+    || ALLOW_DECISIONS.has(token)
+  ) {
+    return 'allow';
+  }
+  return 'unknown';
+}
+
+function normalizePolicyDecision(input = {}, options = {}) {
+  const value = extractPolicyDecision(input);
+  const decision = classifyPolicyDecision(value);
+  const source = firstString(
+    options.source,
+    value.source,
+    value.provider,
+    value.engine,
+    value.policyEngine,
+    value.policy_engine,
+    'policy-engine'
+  );
+  const reason = firstString(
+    value.reason,
+    value.message,
+    value.explanation,
+    value.summary,
+    asArray(value.reasoning).join('; '),
+    asArray(value.reasons).join('; '),
+    decision === 'unknown' ? 'Policy engine returned an unknown decision; approval required before execution.' : ''
+  );
+
+  return {
+    allowed: decision === 'allow',
+    blocked: decision === 'block',
+    approvalRequired: decision === 'approval_required' || decision === 'unknown',
+    decision,
+    reason,
+    source,
+    confidence: Number.isFinite(Number(value.confidence)) ? Number(value.confidence) : null,
+    policyId: firstString(value.policyId, value.policy_id, value.ruleId, value.rule_id, value.id),
+    severity: firstString(value.severity, value.level, value.threat_level, value.threatLevel),
+    score: Number.isFinite(Number(value.score))
+      ? Number(value.score)
+      : (Number.isFinite(Number(value.threat_score)) ? Number(value.threat_score) : null),
+    evidence: normalizeEvidence(value),
+    raw: value,
+  };
+}
+
+function normalizePolicyAction(input = {}) {
+  const event = asObject(input);
+  return {
+    ...normalizeProviderAction({
+      ...event,
+      provider: firstString(event.provider, event.agentRuntime, event.runtime, 'policy-engine'),
+      toolName: firstString(event.toolName, event.tool_name, event.name),
+      input: asObject(event.toolInput || event.input || event.arguments || event.args),
+    }),
+    policyContext: asObject(event.policyContext || event.policy_context),
+  };
+}
+
+function createPolicyEngineGuard({
+  policyCheck,
+  executeTool,
+  gateCheck,
+  onDecision,
+  source = 'policy-engine',
+} = {}) {
+  if (typeof policyCheck !== 'function') {
+    throw new TypeError('createPolicyEngineGuard requires a policyCheck function');
+  }
+  if (typeof executeTool !== 'function') {
+    throw new TypeError('createPolicyEngineGuard requires an executeTool function');
+  }
+
+  return async function guardedPolicyTool(input = {}) {
+    const normalizedAction = normalizePolicyAction(input);
+    const policyDecision = normalizePolicyDecision(await policyCheck(normalizedAction), { source });
+    const gateDecision = typeof gateCheck === 'function'
+      ? normalizePolicyDecision(await gateCheck({ normalizedAction, policyDecision }), { source: 'thumbgate' })
+      : null;
+    const effectiveDecision = gateDecision && !gateDecision.allowed ? gateDecision : policyDecision;
+
+    if (typeof onDecision === 'function') {
+      await onDecision({ normalizedAction, policyDecision, gateDecision, effectiveDecision });
+    }
+
+    if (!effectiveDecision.allowed) {
+      const error = new Error(effectiveDecision.reason || 'ThumbGate blocked this action before execution.');
+      error.code = effectiveDecision.approvalRequired ? 'THUMBGATE_APPROVAL_REQUIRED' : 'THUMBGATE_BLOCKED';
+      error.thumbgate = { normalizedAction, policyDecision, gateDecision, effectiveDecision };
+      throw error;
+    }
+
+    return executeTool(input, { normalizedAction, policyDecision, gateDecision, effectiveDecision });
+  };
+}
+
+module.exports = {
+  createPolicyEngineGuard,
+  extractPolicyDecision,
+  normalizePolicyAction,
+  normalizePolicyDecision,
+};

package/bench/observability-eval-suite.json

@@ -0,0 +1,26 @@
+{
+  "cases": [
+    {
+      "id": "checkout-link-grounding",
+      "traceId": "trace_checkout_001",
+      "question": "Is the Pro checkout link working?",
+      "response": "The Pro checkout link is working because the checkout diagnostic confirms Stripe Pro checkout is reachable.",
+      "retrievedContexts": [
+        "Stripe Pro checkout diagnostic confirms the Pro checkout link is reachable and returns a valid checkout target.",
+        "The workflow sprint checkout is intake-led and should not expose a stale payment link."
+      ],
+      "reference": "The Pro checkout link is reachable when the Stripe diagnostic passes."
+    },
+    {
+      "id": "letta-tool-gate",
+      "traceId": "trace_letta_001",
+      "question": "Should Letta execute a force push tool call?",
+      "response": "ThumbGate blocks force push before execution for Letta tool calls.",
+      "retrievedContexts": [
+        "ThumbGate's Letta adapter wraps Letta tool calls and runs gate-check before the executor is called.",
+        "Force push to main is a blocked high-risk git action."
+      ],
+      "reference": "ThumbGate blocks high-risk Letta tool calls before execution."
+    }
+  ]
+}

package/bin/cli.js

@@ -134,7 +134,7 @@ function upgradeNudge() {
     '\n  Team rollout: start with the $499 Workflow Hardening Diagnostic\n' +
     `  ${diagnosticUrl}\n` +
     `\n  Solo side lane: Pro — ${PRO_PRICE_LABEL}\n` +
-    '  Keeps lessons, rules, and the dashboard synced across machines and agent runtimes.\n' +
+    '  Removes solo caps; adds personal recall, dashboard proof, exports, and managed adapters.\n' +
     `  ${pricingUrl}\n\n`
   );
 }
@@ -234,9 +234,9 @@ function proNudge(context) {
   const checkoutUrl = checkoutUrlFor('cli_nudge', context || COMMAND || 'general');
   const pricingUrl = pricingUrlFor('cli_nudge', context || COMMAND || 'general');
   const messages = [
-    `\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`,
+    `\n  💡 Pro (${PRO_PRICE_LABEL}): personal recall, dashboard proof, exports, and managed adapters.\n     See pricing: ${pricingUrl}\n`,
+    `\n  💡 You just taught ThumbGate something locally. Pro keeps personal lessons searchable and exportable without free-tier caps.\n     See pricing: ${pricingUrl}\n`,
+    `\n  💡 ThumbGate Pro maintains adapter coverage 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];
@@ -921,7 +921,7 @@ function init(cliArgs = parseArgs(process.argv.slice(3))) {
     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('  --agent <name>           Wire a specific agent: claude-code, codex, gemini, amp, cursor, cline, opencode');
     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');
@@ -1593,6 +1593,7 @@ function pro() {
   trackEvent('cli_pro_view', { command: 'pro' });
   const args = parseArgs(process.argv.slice(3));
   const {
+    notifyHostedProActivation,
     resolveProKey,
     saveLicense,
     startLocalProDashboard,
@@ -1606,9 +1607,10 @@ function pro() {
     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('  - Personal recall: search lessons, rules, and proof');
     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('  - Managed adapters: Claude Code, Cursor, Codex, Gemini, Amp, Cline, OpenCode');
+    console.log('  - Team rollout path: Enterprise adds shared hosted lessons, org visibility, workflow proof');
     console.log('  - Commercial truth doc: source of truth for traction, pricing, and proof claims');
     console.log('\nLinks:');
     console.log(`  Buy Pro         : ${PRO_CHECKOUT_URL}`);
@@ -1661,7 +1663,22 @@ function pro() {
     console.log('\n✅ Pro license activated!');
     console.log(`   Key saved to: ${licensePath}`);
     console.log('   Launching your personal local dashboard...\n');
-    return launchDashboard(license.key, 'pro_activate');
+    return notifyHostedProActivation({
+      key: license.key,
+      source: 'cli_pro_activate',
+      version: license.version,
+    })
+      .then((notificationResult) => {
+        appendLocalTelemetry({
+          eventType: 'pro_activation_alert',
+          version: license.version,
+          timestamp: new Date().toISOString(),
+          notified: Boolean(notificationResult && notificationResult.notified),
+          sent: Boolean(notificationResult && notificationResult.alert && notificationResult.alert.sent),
+          reason: notificationResult && notificationResult.reason ? notificationResult.reason : null,
+        });
+        return launchDashboard(license.key, 'pro_activate');
+      });
   }
 
   if (args.upgrade) {
@@ -3934,6 +3951,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; });
@@ -3941,7 +3959,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`);

package/bin/dashboard-cli.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+'use strict';
+
+// Insert 'dashboard' and '--open' as the subcommands/arguments
+process.argv.splice(2, 0, 'dashboard', '--open');
+
+require('./cli.js');

package/bin/postinstall.js

@@ -15,41 +15,32 @@ if (isCI || isQuiet) process.exit(0);
 const {
   PRO_MONTHLY_PAYMENT_LINK,
   PRO_PRICE_LABEL,
+  TEAM_PRICE_LABEL,
 } = require('../scripts/commercial-offer');
 
 // Tracked click-through path: /go/pro → /checkout/pro → Stripe.
+// This captures UTM attribution in our funnel before handing off to Stripe.
 const PRO_CTA_URL = 'https://thumbgate.ai/go/pro?utm_source=npm&utm_medium=postinstall&utm_campaign=first_dollar';
+const WORKFLOW_SPRINT_URL = 'https://thumbgate.ai/#workflow-sprint-intake';
 const DASHBOARD_URL = 'https://thumbgate.ai/dashboard?utm_source=npm&utm_medium=postinstall&utm_campaign=dashboard_nudge';
 
 process.stderr.write(`
   ╭─────────────────────────────────────────────────────╮
-  │  ThumbGate installed.                               │
+  │  ThumbGate installed — 7-day Pro trial is live.     │
   │                                                     │
-  │  Every repeat-mistake your agent makes costs        │
-  │  tokens. ThumbGate blocks known-bad tool calls      │
-  │  BEFORE the model sees them — zero tokens spent     │
-  │  on mistakes you've already corrected.              │
+  │  Start now:  npx thumbgate init                     │
+  │  Updates:    npx thumbgate subscribe you@company.com│
   │                                                     │
-  │  Start free (local-only, never expires):            │
-  │    npx thumbgate init                               │
-  │    npx thumbgate stats                              │
-  │                                                     │
-  │  See your gates firing live:                        │
-  │    ${DASHBOARD_URL.slice(0, 47).padEnd(47, ' ')} │
+  │  Free after trial: 3 rules, 2 captures/day.        │
+  │  Pro ($19/mo): unlimited everything.                │
   ╰─────────────────────────────────────────────────────╯
 
-  Pro — ${PRO_PRICE_LABEL}
-    Hosted lesson sync across all your machines.
-    Adapter matrix kept current for Claude Code,
-    Cursor, Codex, Gemini, Amp, Cline, OpenCode.
-    Org dashboard. DPO export. 24×7 ops.
-    Upgrade: ${PRO_CTA_URL}
-    Direct:  ${PRO_MONTHLY_PAYMENT_LINK}
-
-  ⚡ LAUNCH PROMO: 50% off first 3 months with code THUMB50
-    One-click (discount applied): https://buy.stripe.com/eVqeVd62o0aO19v7mb3sI3g
-    Limited to first 50 customers. July 2026
+  Trial unlocks: unlimited rules, lesson search, DPO export,
+  and personal dashboard proof. After 7 days, free tier limits apply.
+  Subscribe for the 5-min setup guide + weekly tips:
+  npx thumbgate subscribe you@company.com
 
-  Or run: npx thumbgate pro
+  Dashboard: ${DASHBOARD_URL}
+  Keep Pro: ${PRO_CTA_URL}
 
 `);

package/commands/dashboard.md

@@ -0,0 +1,15 @@
+---
+name: dashboard
+description: Open the local HTTP dashboard for the current project in your web browser.
+---
+
+# Open Dashboard
+
+Open the local HTTP dashboard for the current project in your web browser.
+
+## Instructions
+Execute the following command in the project directory to open the browser dashboard scoped to the current repository:
+```bash
+thumbgate-dashboard
+```
+

package/commands/thumbgate-dashboard.md

@@ -0,0 +1,15 @@
+---
+name: thumbgate-dashboard
+description: Open the local HTTP dashboard for the current project in your web browser.
+---
+
+# Open Scoped ThumbGate Dashboard
+
+Open the local HTTP dashboard for the current project in your web browser.
+
+## Instructions
+Execute the following command in the project directory to open the browser dashboard:
+```bash
+thumbgate-dashboard
+```
+

package/config/entitlement-public-keys.json

@@ -0,0 +1,6 @@
+{
+  "activeKid": "tgk_fd49d8ab2055",
+  "keys": {
+    "tgk_fd49d8ab2055": "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAEBVF8rLha9zsIhuiZ0CCslJK0SuCG6HL/bWXbkYVRiA=\n-----END PUBLIC KEY-----\n"
+  }
+}

package/config/gates/default.json

@@ -210,7 +210,7 @@
     {
       "id": "deny-network-egress",
       "layer": "Cloud",
-      "pattern": "curl\\s|wget\\s|fetch\\(|https?://(?!github\\.com|registry\\.npmjs\\.org|api\\.anthropic\\.com)",
+      "pattern": "fetch\\(|https?://(?!(?:github\\.com|registry\\.npmjs\\.org|api\\.anthropic\\.com|localhost|127\\.0\\.0\\.1|\\[::1\\]|0\\.0\\.0\\.0)(?:[:/?#]|$))|(?:curl|wget)\\s+(?:-\\S+\\s+)*(?!https?://|(?:github\\.com|registry\\.npmjs\\.org|api\\.anthropic\\.com|localhost|127\\.0\\.0\\.1|\\[::1\\]|0\\.0\\.0\\.0)(?:[:/?#]|$))[\\w.-]+\\.[a-z]{2,}",
       "action": "warn",
       "unless": "egress_approved",
       "message": "Potential unauthorized network egress detected.",

package/config/github-about.json

@@ -2,8 +2,8 @@
   "repo": "IgorGanapolsky/ThumbGate",
   "repositoryUrl": "https://github.com/IgorGanapolsky/ThumbGate",
   "homepageUrl": "https://thumbgate.ai",
-  "githubDescription": "Agent governance for ThumbGate: 👍/👎 become Pre-Action Checks that block repeat mistakes before code, money, or customer systems change.",
-  "metaDescription": "Stripe Connect integration engineering for ticketing and marketplace platforms — Pretix plugin shipped to Hilltown Media. ThumbGate is also the pre-action governance runtime for AI coding agents (Claude Code, Cursor, Codex, Gemini CLI): 👍 thumbs up and 👎 thumbs down feedback become history-aware lessons, shared lessons and org visibility, and PreToolUse checks that block repeated mistakes before code, money, or customer systems change. Perfect for vibe coding and human-in-the-loop workflows.",
+  "githubDescription": "Agent governance: thumbs become Pre-Action Checks that flag repeat mistakes and hard-block catastrophic classes before code or systems change.",
+  "metaDescription": "ThumbGate is the pre-action governance runtime for AI coding agents (Claude Code, Cursor, Codex, Gemini CLI, Amp, Cline, OpenCode): 👍 thumbs up and 👎 thumbs down feedback become history-aware lessons stored locally; Enterprise adds shared lessons and org visibility. PreToolUse checks flag and log risky tool calls — hard-blocking catastrophic classes by default and warning on the rest, with strict mode to hard-block every rule.",
   "topics": [
     "thumbgate",
     "pre-action-checks",

package/config/merge-quality-checks.json

@@ -18,5 +18,8 @@
   "failingBuckets": [
     "fail",
     "cancel"
+  ],
+  "selfReferentialChecks": [
+    "Trunk Merge Queue (main)"
   ]
 }