thumbgate 1.27.19 → 1.27.20

package/adapters/letta/thumbgate-letta-adapter.js

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+'use strict';
+
+const { normalizeProviderAction } = require('../../scripts/provider-action-normalizer');
+
+function asObject(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function firstString(...values) {
+  for (const value of values) {
+    const text = String(value || '').trim();
+    if (text) return text;
+  }
+  return '';
+}
+
+function extractLettaToolCall(input = {}) {
+  const event = asObject(input);
+  const toolCall = asObject(event.toolCall || event.tool_call || event.lettaToolCall);
+  const functionCall = asObject(toolCall.function || event.function);
+  const mcp = asObject(event.mcp || event.mcpToolCall);
+  const clientTool = asObject(event.clientTool || event.client_tool);
+  const params = asObject(event.params);
+
+  const name = firstString(
+    event.toolName,
+    event.name,
+    toolCall.name,
+    functionCall.name,
+    clientTool.name,
+    mcp.name,
+    params.name
+  );
+  const args = asObject(
+    event.arguments
+      || event.args
+      || event.input
+      || toolCall.arguments
+      || toolCall.input
+      || functionCall.arguments
+      || clientTool.arguments
+      || clientTool.input
+      || mcp.arguments
+      || params.arguments
+  );
+
+  return {
+    id: firstString(event.id, event.toolCallId, event.tool_call_id, toolCall.id, clientTool.id),
+    name,
+    arguments: args,
+    server: firstString(event.mcpServer, mcp.server, params.server),
+    surface: firstString(event.surface, event.executionSurface, clientTool.name ? 'client-tool' : mcp.name || params.name ? 'mcp-tool' : 'server-tool'),
+  };
+}
+
+function normalizeLettaAction(input = {}) {
+  const event = asObject(input);
+  const toolCall = extractLettaToolCall(event);
+
+  const normalized = normalizeProviderAction({
+    ...event,
+    provider: 'letta',
+    toolCall: {
+      id: toolCall.id,
+      name: toolCall.name,
+      input: toolCall.arguments,
+    },
+    toolName: toolCall.name,
+    input: toolCall.arguments,
+    mcpServer: toolCall.server,
+  });
+
+  return {
+    ...normalized,
+    provider: 'letta',
+    agentRuntime: 'letta',
+    letta: {
+      agentId: firstString(event.agentId, event.agent_id),
+      messageId: firstString(event.messageId, event.message_id),
+      surface: toolCall.surface,
+      toolCallId: toolCall.id,
+    },
+  };
+}
+
+function normalizeGateDecision(decision = {}) {
+  const value = asObject(decision);
+  const raw = firstString(value.decision, value.mode, value.action, value.status).toLowerCase();
+  const blocked = value.allowed === false
+    || value.accepted === false
+    || value.blocked === true
+    || ['block', 'deny', 'denied', 'reject', 'rejected'].includes(raw);
+  const approvalRequired = value.requiresApproval === true || raw === 'approve';
+  return {
+    allowed: !blocked && !approvalRequired,
+    blocked,
+    approvalRequired,
+    reason: firstString(value.reason, value.message, Array.isArray(value.reasons) ? value.reasons.join('; ') : ''),
+    raw: value,
+  };
+}
+
+function createLettaToolGuard({ gateCheck, executeTool, onDecision } = {}) {
+  if (typeof gateCheck !== 'function') {
+    throw new TypeError('createLettaToolGuard requires a gateCheck function');
+  }
+  if (typeof executeTool !== 'function') {
+    throw new TypeError('createLettaToolGuard requires an executeTool function');
+  }
+
+  return async function guardedLettaTool(input = {}) {
+    const normalizedAction = normalizeLettaAction(input);
+    const decision = normalizeGateDecision(await gateCheck(normalizedAction));
+    if (typeof onDecision === 'function') {
+      await onDecision({ normalizedAction, decision });
+    }
+    if (!decision.allowed) {
+      const error = new Error(decision.reason || 'ThumbGate blocked this Letta tool call before execution.');
+      error.code = decision.approvalRequired ? 'THUMBGATE_APPROVAL_REQUIRED' : 'THUMBGATE_BLOCKED';
+      error.thumbgate = { normalizedAction, decision };
+      throw error;
+    }
+    return executeTool(input, { normalizedAction, decision });
+  };
+}
+
+module.exports = {
+  createLettaToolGuard,
+  extractLettaToolCall,
+  normalizeGateDecision,
+  normalizeLettaAction,
+};

package/adapters/mcp/server-stdio.js

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

package/adapters/opencode/opencode.json

@@ -7,7 +7,7 @@
         "npx",
         "--yes",
         "--package",
-        "thumbgate@1.27.15",
+        "thumbgate@1.27.20",
         "thumbgate",
         "serve"
       ],

package/adapters/policy-engine/ethicore-guardian-client.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+'use strict';
+
+const DEFAULT_ENDPOINT = 'https://api.oraclestechnologies.com/v1/guardian/analyze';
+
+function requireApiKey(env = process.env) {
+  const key = env.ETHICORE_API_KEY || env.GUARDIAN_API_KEY || env.ORACLES_GUARDIAN_API_KEY;
+  if (!key) {
+    throw new Error('ETHICORE_API_KEY env var is required');
+  }
+  return key;
+}
+
+async function analyzeText(text, options = {}) {
+  if (!String(text || '').trim()) {
+    throw new Error('analyzeText requires text');
+  }
+
+  const env = options.env || process.env;
+  const endpoint = options.endpoint || env.ETHICORE_GUARDIAN_ENDPOINT || DEFAULT_ENDPOINT;
+  const apiKey = options.apiKey || requireApiKey(env);
+  const fetchImpl = options.fetch || fetch;
+
+  const response = await fetchImpl(endpoint, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({ text }),
+  });
+
+  const bodyText = await response.text();
+  let body = bodyText;
+  try {
+    body = bodyText ? JSON.parse(bodyText) : {};
+  } catch {
+    // Keep non-JSON body for diagnostics.
+  }
+
+  if (!response.ok) {
+    throw new Error(`Ethicore Guardian API ${response.status}: ${typeof body === 'string' ? body : JSON.stringify(body)}`);
+  }
+
+  return body;
+}
+
+function createEthicorePolicyCheck(options = {}) {
+  return async function ethicorePolicyCheck(action = {}) {
+    const toolText = [
+      action.toolName,
+      action.actionType,
+      action.command,
+      action.path,
+      action.url,
+      action.input ? JSON.stringify(action.input) : '',
+    ].filter(Boolean).join('\n');
+
+    return analyzeText(toolText || JSON.stringify(action), options);
+  };
+}
+
+module.exports = {
+  DEFAULT_ENDPOINT,
+  analyzeText,
+  createEthicorePolicyCheck,
+  requireApiKey,
+};

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

@@ -3934,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; });
@@ -3941,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`);

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,
+  hosted dashboard. 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
+```
+