thumbgate 1.27.16 → 1.27.18

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

@@ -1,68 +0,0 @@
-#!/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

@@ -1,260 +0,0 @@
-#!/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

@@ -1,26 +0,0 @@
-{
-  "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/dashboard-cli.js

@@ -1,7 +0,0 @@
-#!/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/commands/dashboard.md

@@ -1,15 +0,0 @@
----
-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

@@ -1,15 +0,0 @@
----
-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/builtin-lessons.json

@@ -1,23 +0,0 @@
-{
-  "version": 1,
-  "lessons": [
-    {
-      "id": "builtin-response-quality-shallow-positive-closeout",
-      "title": "MISTAKE: Assistant gave shallow acknowledgement after user said thumbs up",
-      "content": "What went wrong: Assistant gave shallow acknowledgement after positive feedback, such as thumbs up, perfect, good, or thank you, instead of staying quiet or giving an evidence checkpoint.\nHow to avoid: If the previous user message is positive feedback and the proposed final response is a low-value social closeout, block it and require either silence-level brevity or a compact evidence checkpoint with proof, result, residual risk, and next state.\nAction needed: Enforce this at the final-response boundary, not only as PreToolUse context.\nReasoning: Stored lessons and retrieval are not enough when the model can still ignore the lesson at generation time.",
-      "category": "error",
-      "importance": "high",
-      "tags": [
-        "feedback",
-        "negative",
-        "response-quality",
-        "final-response",
-        "positive-feedback",
-        "shallow-closeout",
-        "enforcement"
-      ],
-      "timestamp": "2026-06-20T19:01:58.000Z",
-      "source": "packaged-builtin"
-    }
-  ]
-}

package/config/gate-classifier-routing.json

@@ -1,98 +0,0 @@
-{
-  "version": 1,
-  "defaultLane": "local_classical",
-  "lanes": {
-    "deterministic": {
-      "description": "Regex, allow/deny lists, protected paths, branch rules, and exact policy checks. Always runs first.",
-      "maxLatencyMs": 25,
-      "cloudAllowed": false,
-      "useFor": [
-        "secret patterns",
-        "force-push",
-        "destructive SQL",
-        "protected operating files",
-        "known repeated command signatures"
-      ]
-    },
-    "semantic_cache": {
-      "description": "Cached decision for semantically equivalent repeats where wording or PII changed but action meaning did not.",
-      "maxLatencyMs": 50,
-      "cloudAllowed": false,
-      "requiresProvenance": true,
-      "useFor": [
-        "semantic repeat blocks",
-        "cached approvals",
-        "prompt variants with same action meaning",
-        "PII-normalized duplicate checks"
-      ]
-    },
-    "local_classical": {
-      "description": "Fast local text routing for high-volume, low-ambiguity feedback and gate labels.",
-      "maxLatencyMs": 250,
-      "cloudAllowed": false,
-      "minExamples": 40,
-      "useFor": [
-        "routine feedback triage",
-        "known error classes",
-        "low-risk support labels",
-        "bulk import classification"
-      ]
-    },
-    "local_semantic": {
-      "description": "Local semantic/FTS recall for near-miss lessons, fuzzy duplicates, and low-data labels.",
-      "maxLatencyMs": 750,
-      "cloudAllowed": false,
-      "useFor": [
-        "near-duplicate lessons",
-        "sparse labels",
-        "cross-session recurrence",
-        "similar command intent"
-      ]
-    },
-    "llm_judge": {
-      "description": "Budget-capped LLM review for ambiguous, high-value decisions where semantics matter.",
-      "maxLatencyMs": 10000,
-      "cloudAllowed": true,
-      "requiresEvidence": true,
-      "useFor": [
-        "ambiguous policy mapping",
-        "multi-document evidence review",
-        "rubric critique",
-        "structured dataset provenance review"
-      ]
-    },
-    "rubric_gate": {
-      "description": "Completion blocker for failed rubrics, missing evidence, and loop-until-done harness caps.",
-      "maxLatencyMs": 500,
-      "cloudAllowed": false,
-      "requiresEvidence": true,
-      "useFor": [
-        "failed rubric criteria",
-        "missing done evidence",
-        "critic review failure",
-        "workflow completion claims"
-      ]
-    },
-    "human_review": {
-      "description": "Stop and ask for approval when the action is high-risk, private, or too ambiguous for automated routing.",
-      "maxLatencyMs": null,
-      "cloudAllowed": false,
-      "requiresEvidence": true,
-      "useFor": [
-        "production credentials",
-        "customer data",
-        "regulated workflows",
-        "unbounded external posting",
-        "payment or refund changes"
-      ]
-    }
-  },
-  "thresholds": {
-    "classicalMinExamples": 40,
-    "lowLatencyBudgetMs": 300,
-    "llmMinLatencyBudgetMs": 2000,
-    "highRiskAmbiguity": 0.65,
-    "mediumAmbiguity": 0.35,
-    "largeBatchRows": 50
-  }
-}

package/config/post-deploy-marketing-pages.json

@@ -1,61 +0,0 @@
-{
-  "$comment": "Sentinel manifest for post-deploy verification of top-level marketing pages. Each entry is curled against the live production URL after every push to main; if the sentinel string is missing from the response body, the deploy is flagged as broken and the workflow comments on the associated PR. Adding a new top-level marketing page? Add it here so the deploy-verify workflow catches a route regression before a real visitor does. Keep sentinel strings short and stable (visible body copy, not styling classes or hashed assets).",
-  "version": 1,
-  "pages": [
-    {
-      "route": "/",
-      "sentinel": "Stop paying for the same AI mistake twice",
-      "description": "Home page hero (lifeblood — never regress)"
-    },
-    {
-      "route": "/pro",
-      "sentinel": "ThumbGate Pro",
-      "description": "Pro landing page"
-    },
-    {
-      "route": "/dashboard",
-      "sentinel": "ThumbGate Dashboard",
-      "description": "Dashboard demo (already enforced by /dashboard step; included here for symmetry with PR comment surface)"
-    },
-    {
-      "route": "/federal",
-      "sentinel": "ThumbGate",
-      "description": "Federal lead-gen page (SBIR / GSA arrivals)"
-    },
-    {
-      "route": "/numbers",
-      "sentinel": "ThumbGate",
-      "description": "First-party numbers / data transparency page"
-    },
-    {
-      "route": "/ai-malpractice-prevention",
-      "sentinel": "Pre-Execution Controls for Legal AI Agents",
-      "description": "Legal AI intake risk-controls page for law-firm pilot conversations"
-    },
-    {
-      "route": "/learn/background-agent-control-layer",
-      "sentinel": "Background agents need a control layer outside the model",
-      "description": "Background-agent AI-SDLC control-layer positioning page"
-    },
-    {
-      "route": "/llm-context.md",
-      "sentinel": "## What ThumbGate Is",
-      "description": "Canonical declarative summary AI crawlers read"
-    },
-    {
-      "route": "/robots.txt",
-      "sentinel": "User-agent",
-      "description": "Crawl directives (mandatory per Google's 2026-05-15 AI features guide)"
-    },
-    {
-      "route": "/sitemap.xml",
-      "sentinel": "<urlset",
-      "description": "XML sitemap for search-engine discoverability"
-    },
-    {
-      "route": "/about",
-      "sentinel": "Igor Ganapolsky",
-      "description": "About page for GEO discoverability"
-    }
-  ]
-}