npm - thumbgate - Versions diffs - 1.27.11 → 1.27.13 - Mend

thumbgate 1.27.11 → 1.27.13

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (131) hide show

package/.claude-plugin/plugin.json +1 -1
package/.well-known/llms.txt +2 -1
package/.well-known/mcp/server-card.json +1 -1
package/README.md +2 -4
package/adapters/claude/.mcp.json +2 -2
package/adapters/mcp/server-stdio.js +1 -1
package/adapters/opencode/opencode.json +1 -1
package/adapters/policy-engine/ethicore-guardian-client.js +68 -0
package/adapters/policy-engine/thumbgate-policy-engine-adapter.js +260 -0
package/bin/cli.js +78 -259
package/config/builtin-lessons.json +23 -0
package/config/gate-templates.json +0 -228
package/config/gates/claim-verification.json +0 -18
package/package.json +35 -25
package/public/assets/brand/thumbgate-logo-transparent.svg +22 -0
package/public/assets/brand/thumbgate-mark-inline-v3.svg +19 -0
package/public/assets/brand/thumbgate-mark.svg +11 -5
package/public/blog.html +0 -30
package/public/brand/thumbgate-mark.svg +9 -5
package/public/chatgpt-app.html +2 -2
package/public/compare.html +2 -1
package/public/dashboard.html +1 -1
package/public/federal.html +1 -1
package/public/index.html +95 -216
package/public/learn.html +59 -35
package/public/lessons.html +1 -1
package/public/numbers.html +2 -2
package/public/pro.html +7 -7
package/scripts/aws-blocks-guardrails.js +228 -0
package/scripts/cli-schema.js +22 -10
package/scripts/dashboard-chat.js +2 -1
package/scripts/document-intake.js +1 -49
package/scripts/durability/step.js +3 -3
package/scripts/gate-stats.js +5 -11
package/scripts/gemini-embedding-policy.js +2 -1
package/scripts/hook-stop-anti-claim.js +116 -184
package/scripts/hosted-config.js +0 -12
package/scripts/llm-client.js +187 -5
package/scripts/plausible-domain-config.js +3 -1
package/scripts/seo-gsd.js +240 -1
package/scripts/tool-registry.js +2 -2
package/scripts/vector-store.js +44 -0
package/scripts/workspace-evolver.js +62 -2
package/src/api/server.js +340 -131
package/public/assets/brand/thumbgate-mark-inline.svg +0 -15
package/public/compare/adopt-ai.html +0 -219
package/public/compare/agentix-labs.html +0 -197
package/public/compare/ai-experience-orchestration.html +0 -216
package/public/compare/anthropic-claude-for-legal.html +0 -260
package/public/compare/anthropic-containment.html +0 -280
package/public/compare/arcade.html +0 -175
package/public/compare/arcjet.html +0 -239
package/public/compare/bumblebee.html +0 -307
package/public/compare/claude-code-hooks.html +0 -294
package/public/compare/databricks-unity-ai-gateway.html +0 -215
package/public/compare/fallow.html +0 -351
package/public/compare/heidi.html +0 -233
package/public/compare/mem0.html +0 -342
package/public/compare/oak-and-sparrow-gatekeeper.html +0 -289
package/public/compare/rein.html +0 -236
package/public/compare/sigmashake.html +0 -256
package/public/compare/speclock.html +0 -342
package/public/guides/agent-harness-optimization.html +0 -342
package/public/guides/agentic-web-governance.html +0 -406
package/public/guides/ai-agent-governance-sprint.html +0 -415
package/public/guides/ai-agent-pre-action-approval-gates.html +0 -401
package/public/guides/ai-agent-workflow-migration-checklist.html +0 -392
package/public/guides/ai-deployment-readiness.html +0 -415
package/public/guides/ai-mode-ads-agent-governance.html +0 -401
package/public/guides/ai-search-topical-presence.html +0 -342
package/public/guides/autoresearch-agent-safety.html +0 -342
package/public/guides/background-agent-governance.html +0 -358
package/public/guides/best-tools-stop-ai-agents-breaking-production.html +0 -363
package/public/guides/browser-automation-safety.html +0 -342
package/public/guides/chatgpt-ads-trust.html +0 -353
package/public/guides/claude-code-feedback.html +0 -339
package/public/guides/claude-code-prevent-repeated-mistakes.html +0 -161
package/public/guides/claude-code-skills-guardrails.html +0 -343
package/public/guides/claude-desktop.html +0 -356
package/public/guides/code-knowledge-graph-guardrails.html +0 -365
package/public/guides/codex-cli-guardrails.html +0 -339
package/public/guides/cursor-agent-guardrails.html +0 -339
package/public/guides/cursor-prevent-repeated-mistakes.html +0 -161
package/public/guides/database-agent-safety.html +0 -406
package/public/guides/deepseek-v4-runtime-guardrails.html +0 -346
package/public/guides/developer-machine-supply-chain-guardrails.html +0 -358
package/public/guides/gcp-mcp-guardrails.html +0 -147
package/public/guides/gemini-cli-feedback-memory.html +0 -339
package/public/guides/gpt-5-5-model-evaluation.html +0 -358
package/public/guides/internal-ai-engineering-stack-guardrails.html +0 -348
package/public/guides/long-running-agent-context-management.html +0 -346
package/public/guides/mcp-tool-governance.html +0 -401
package/public/guides/multica-thumbgate-setup.html +0 -134
package/public/guides/native-messaging-host-security.html +0 -342
package/public/guides/policy-engine-pre-action-gates.html +0 -346
package/public/guides/pre-action-checks.html +0 -342
package/public/guides/pretooluse-hooks-vs-advisory-prompt-rules.html +0 -342
package/public/guides/prompt-tricks-to-workflow-rules.html +0 -365
package/public/guides/proxy-pointer-rag-guardrails.html +0 -352
package/public/guides/rag-precision-tuning-guardrails.html +0 -352
package/public/guides/reasoning-compression-guardrails.html +0 -346
package/public/guides/relational-knowledge-ai-recommendations.html +0 -342
package/public/guides/roo-code-alternative-cline.html +0 -339
package/public/guides/semantic-programmatic-seo-guardrails.html +0 -352
package/public/guides/seo-agent-skills-guardrails.html +0 -344
package/public/guides/stop-repeated-ai-agent-mistakes.html +0 -342
package/public/learn/ac-dc-runtime-enforcement.html +0 -277
package/public/learn/agent-harness-pattern.html +0 -181
package/public/learn/agent-identity-connector-governance.html +0 -146
package/public/learn/agent-swarms-shared-gates.html +0 -173
package/public/learn/agentic-enterprise-context-brain.html +0 -117
package/public/learn/agentic-os-team-governance.html +0 -146
package/public/learn/ai-agent-governance.html +0 -158
package/public/learn/ai-agent-persistent-memory.html +0 -211
package/public/learn/anthropomorphic-claim-gates.html +0 -180
package/public/learn/background-agent-control-layer.html +0 -184
package/public/learn/claude-code-goal-with-rubrics.html +0 -205
package/public/learn/codex-role-plugins-need-governance.html +0 -125
package/public/learn/cost-aware-agent-gate-routing.html +0 -173
package/public/learn/databricks-unity-ai-gateway-runtime-governance.html +0 -157
package/public/learn/deterministic-agent-workflows.html +0 -185
package/public/learn/feedback-loop-vs-decision-layer.html +0 -283
package/public/learn/from-prototype-to-production.html +0 -223
package/public/learn/learn.css +0 -51
package/public/learn/mcp-pre-action-checks-explained.html +0 -172
package/public/learn/pretix-stripe-connect-marketplaces.html +0 -161
package/public/learn/regulated-agent-execution-boundary.html +0 -196
package/public/learn/spec-driven-development.html +0 -168
package/public/learn/stop-ai-agent-force-push.html +0 -134
package/public/learn/vibe-coding-safety-net.html +0 -142
package/scripts/reddit-browser-notification-watch.js +0 -230

package/public/learn/databricks-unity-ai-gateway-runtime-governance.html DELETED Viewed

@@ -1,157 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-<meta charset="UTF-8">
-<meta name="viewport" content="width=device-width, initial-scale=1.0">
-<title>Databricks Unity AI Gateway validates runtime AI governance - ThumbGate</title>
-<script defer data-domain="thumbgate.ai" src="https://plausible.io/js/script.js"></script>
-<meta name="description" content="Databricks Unity AI Gateway makes runtime AI governance mainstream. The next layer is local pre-action enforcement before developer agents call shell, browser, API, MCP, file, or deploy tools.">
-<meta name="keywords" content="Databricks Unity AI Gateway, AI governance, MCP governance, AI gateway, pre-action enforcement, PreToolUse, ThumbGate">
-<meta property="og:title" content="Databricks validates runtime AI governance">
-<meta property="og:description" content="Enterprise gateways govern the fleet. Local pre-action gates stop the agent action before it fires.">
-<meta property="og:type" content="article">
-<meta property="og:url" content="https://thumbgate.ai/learn/databricks-unity-ai-gateway-runtime-governance">
-<link rel="canonical" href="https://thumbgate.ai/learn/databricks-unity-ai-gateway-runtime-governance">
-<link rel="stylesheet" href="/learn/learn.css">
-<script type="application/ld+json">
-{
-  "@context": "https://schema.org",
-  "@type": "TechArticle",
-  "headline": "Databricks Unity AI Gateway validates runtime AI governance",
-  "description": "Databricks Unity AI Gateway makes runtime governance for models, agents, MCP services, tools, guardrails, observability, and AI cost controls mainstream. ThumbGate positions as the local pre-action enforcement layer for developer-agent workflows.",
-  "author": {
-    "@type": "Person",
-    "name": "Igor Ganapolsky",
-    "url": "https://github.com/IgorGanapolsky"
-  },
-  "publisher": {
-    "@type": "Organization",
-    "name": "ThumbGate",
-    "url": "https://thumbgate.ai"
-  },
-  "datePublished": "2026-06-20",
-  "dateModified": "2026-06-20",
-  "mainEntityOfPage": "https://thumbgate.ai/learn/databricks-unity-ai-gateway-runtime-governance",
-  "about": [
-    {"@type": "Thing", "name": "Databricks Unity AI Gateway"},
-    {"@type": "Thing", "name": "runtime AI governance"},
-    {"@type": "Thing", "name": "MCP governance"},
-    {"@type": "Thing", "name": "pre-action gates"}
-  ]
-}
-</script>
-<script type="application/ld+json">
-{
-  "@context": "https://schema.org",
-  "@type": "FAQPage",
-  "mainEntity": [
-    {
-      "@type": "Question",
-      "name": "What does Databricks Unity AI Gateway change for agent governance?",
-      "acceptedAnswer": {
-        "@type": "Answer",
-        "text": "It moves the market conversation from static AI governance to runtime governance across models, agents, MCP services, skills, tools, observability, guardrails, and cost controls."
-      }
-    },
-    {
-      "@type": "Question",
-      "name": "Where does ThumbGate fit?",
-      "acceptedAnswer": {
-        "@type": "Answer",
-        "text": "ThumbGate fits at the local pre-action boundary. It gates the concrete tool action before a developer agent runs shell, edits files, calls MCP tools, opens browsers, hits APIs, or deploys."
-      }
-    },
-    {
-      "@type": "Question",
-      "name": "Is this a Databricks partnership claim?",
-      "acceptedAnswer": {
-        "@type": "Answer",
-        "text": "No. ThumbGate is not claiming partnership, certification, or endorsement by Databricks. The page uses public Databricks materials as market evidence for runtime governance."
-      }
-    }
-  ]
-}
-</script>
-</head>
-<body>
-<nav>
-  <a href="/" class="brand"><img src="/assets/brand/thumbgate-mark-inline.svg" alt="ThumbGate" class="logo-mark" width="28" height="28"><span class="logo-text">ThumbGate</span></a>
-  <a href="/guide">Setup Guide</a>
-  <a href="/learn">Learn</a>
-  <a href="/compare">Compare</a>
-  <a href="https://github.com/IgorGanapolsky/ThumbGate" target="_blank" rel="noopener">GitHub</a>
-</nav>
-<div class="container">
-  <div class="breadcrumb"><a href="/learn">Learn</a> / Databricks Unity AI Gateway</div>
-  <h1>Databricks validates runtime AI governance. The next layer is pre-action enforcement.</h1>
-  <p style="color:var(--muted);">5 min read &middot; For teams turning enterprise gateway announcements into local agent controls</p>
-  <div class="tldr"><strong>TL;DR:</strong> Databricks Unity AI Gateway is a strong market signal: agent governance is moving into runtime interactions across models, agents, MCP services, tools, cost controls, and observability. ThumbGate should ride that signal by owning the local pre-action gate: the moment before a developer agent calls shell, file, browser, API, MCP, or deploy tools.</div>
-  <h2>What Databricks made obvious</h2>
-  <p>Databricks describes Unity AI Gateway as governance for enterprise AI runtime interactions. Its launch materials talk about centralizing access and monitoring across AI providers, coding agents, frameworks, applications, custom AI systems, MCP services, tools, guardrails, and AI cost controls.</p>
-  <p>That matters because it tells the buyer what the market now believes: governance cannot stop at policy documents, model catalogs, or dashboards. Once agents use tools, governance has to sit in the path of runtime decisions.</p>
-  <h2>Gateway vs gate</h2>
-  <p>An enterprise gateway answers questions like: Which model can this app call? Which MCP service is approved? Which team is burning tokens? Which guardrail applies to this route?</p>
-  <p>A local pre-action gate asks a different question: Should this specific agent action run right now?</p>
-  <ul>
-    <li>Should this command run in this directory?</li>
-    <li>Should this file edit proceed without a verified source?</li>
-    <li>Should this Reddit, LinkedIn, X, or Bluesky post publish without action-time confirmation?</li>
-    <li>Should this deploy continue when tests have not run?</li>
-    <li>Should a repeated failure become a durable prevention rule?</li>
-  </ul>
-  <h2>The gap teams still hit locally</h2>
-  <p>Even with a gateway, the developer's local agent can still drift: it can make the same bad claim, call the wrong tool, touch the wrong file, post externally without approval, or spend tokens on a loop that should have stopped earlier. Those are not abstract governance problems. They are workflow failures.</p>
-  <p>ThumbGate's position is not "replace the gateway." The position is: <strong>gateway plus gate</strong>. Use the enterprise gateway for provider, model, service, MCP, and cost governance. Use ThumbGate at the local action boundary where the agent is about to do something irreversible or expensive.</p>
-  <h2>What to test this week</h2>
-  <ol>
-    <li>Pick one repeated developer-agent failure: unsafe shell, unsupported claim, unapproved external post, missing test proof, wrong MCP tool, or runaway loop.</li>
-    <li>Turn it into a ThumbGate rule.</li>
-    <li>Run the workflow again and capture whether the bad action is blocked before the tool fires.</li>
-    <li>Package the result as a small proof run: failure, gate, replay, result.</li>
-  </ol>
-  <div class="callout callout-green">
-    <p><strong>Revenue framing:</strong> Databricks creates air cover for the budget line. ThumbGate sells the proof run: "Show me one workflow where your agent keeps repeating the same expensive mistake, and I will gate it before action."</p>
-  </div>
-  <h2>Sources and positioning</h2>
-  <p>This article is based on public Databricks materials, including the June 2026 Unity AI Gateway launch posts and product page. ThumbGate is not a Databricks partner, product, certification, or endorsed integration. The comparison is architectural positioning.</p>
-  <ul>
-    <li><a href="https://www.databricks.com/blog/ai-governance-data-ai-summit-2026-whats-new-unity-ai-gateway" target="_blank" rel="noopener">Databricks: AI governance at Data + AI Summit 2026</a></li>
-    <li><a href="https://www.databricks.com/blog/whats-new-unity-ai-gateway-service-policies-guardrails-observability-and-cost-controls-ai" target="_blank" rel="noopener">Databricks: service policies, guardrails, observability, and cost controls</a></li>
-    <li><a href="https://www.databricks.com/product/artificial-intelligence/unity-ai-gateway" target="_blank" rel="noopener">Databricks: Unity AI Gateway product page</a></li>
-  </ul>
-  <div class="cta-box">
-    <h2>Run the local gate</h2>
-    <p>Start with one repeated agent failure. Gate it before the action executes.</p>
-    <div class="cta-install">npx thumbgate init</div>
-    <div class="cta-actions">
-      <a class="cta-link" href="/compare/databricks-unity-ai-gateway">Compare gateway vs gate</a>
-      <a class="cta-link cta-link-secondary" href="/learn/mcp-pre-action-checks-explained">Read MCP pre-action checks</a>
-    </div>
-  </div>
-  <div class="related">
-    <h2>Related</h2>
-    <a href="/compare/databricks-unity-ai-gateway">ThumbGate vs Databricks Unity AI Gateway</a>
-    <a href="/learn/cost-aware-agent-gate-routing">Cost-aware agent gate routing</a>
-    <a href="/learn/background-agent-control-layer">Background agent control layer</a>
-  </div>
-</div>
-<div class="sticky-cta">
-  <span>Gate one repeated agent failure</span>
-  <code>npx thumbgate init</code>
-  <a href="/guide?utm_source=databricks_unity_ai_gateway&utm_medium=learn&utm_campaign=runtime_governance">Setup guide</a>
-</div>
-</body>
-</html>

package/public/learn/deterministic-agent-workflows.html DELETED Viewed

@@ -1,185 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-<meta charset="UTF-8">
-<meta name="viewport" content="width=device-width, initial-scale=1.0">
-<title>Deterministic Agent Workflows Need Runtime Gates — ThumbGate</title>
-<script defer data-domain="thumbgate.ai" src="https://plausible.io/js/script.js"></script>
-<meta name="description" content="Claude Code dynamic workflows make orchestration scriptable. Production teams still need deterministic run contracts, evidence, and pre-action gates before multi-agent workflows can be trusted.">
-<meta name="keywords" content="Claude Code workflows, deterministic agent workflows, dynamic workflows, multi-agent orchestration, pre-action gates, workflow hardening, AI agent governance, ThumbGate">
-<meta property="og:title" content="Deterministic Agent Workflows Need Runtime Gates">
-<meta property="og:description" content="Scripted workflows are the right direction. ThumbGate adds the missing layer: pre-action gates, evidence, and repeat-failure prevention before each tool call runs.">
-<meta property="og:type" content="article">
-<meta property="og:url" content="https://thumbgate.ai/learn/deterministic-agent-workflows">
-<link rel="canonical" href="https://thumbgate.ai/learn/deterministic-agent-workflows">
-<script type="application/ld+json">
-{
-  "@context": "https://schema.org",
-  "@type": "TechArticle",
-  "headline": "Deterministic Agent Workflows Need Runtime Gates",
-  "description": "Claude Code dynamic workflows make orchestration scriptable. Production teams still need deterministic run contracts, evidence, and pre-action gates before multi-agent workflows can be trusted.",
-  "author": {
-    "@type": "Person",
-    "name": "Igor Ganapolsky",
-    "url": "https://github.com/IgorGanapolsky"
-  },
-  "publisher": {
-    "@type": "Organization",
-    "name": "ThumbGate",
-    "url": "https://thumbgate.ai"
-  },
-  "datePublished": "2026-06-03",
-  "dateModified": "2026-06-03",
-  "mainEntityOfPage": "https://thumbgate.ai/learn/deterministic-agent-workflows",
-  "about": [
-    {"@type": "Thing", "name": "Claude Code workflows"},
-    {"@type": "Thing", "name": "deterministic agent workflows"},
-    {"@type": "Thing", "name": "pre-action gates"},
-    {"@type": "Thing", "name": "multi-agent orchestration"}
-  ]
-}
-</script>
-<link rel="stylesheet" href="/learn/learn.css">
-<style>
-  .matrix { width: 100%; border-collapse: collapse; margin: 1rem 0 1.5rem; }
-  .matrix th, .matrix td { text-align: left; padding: 0.7rem 0.8rem; border-bottom: 1px solid var(--border); vertical-align: top; }
-  .matrix th { color: var(--cyan); font-weight: 600; }
-  .run-contract { background: var(--bg-card); border: 1px solid var(--border); border-radius: 8px; padding: 1rem; margin: 1rem 0; }
-  .run-contract code { white-space: pre-wrap; }
-</style>
-</head>
-<body>
-<nav>
-  <a href="/" class="brand"><img src="/assets/brand/thumbgate-mark-inline.svg" alt="ThumbGate" class="logo-mark" width="28" height="28"><span class="logo-text">ThumbGate</span></a>
-  <a href="/guide">Setup Guide</a>
-  <a href="/learn">Learn</a>
-  <a href="/dashboard">Dashboard</a>
-  <a href="https://github.com/IgorGanapolsky/ThumbGate" target="_blank" rel="noopener">GitHub</a>
-</nav>
-<div class="container">
-  <div class="breadcrumb"><a href="/learn">Learn</a> / Deterministic Agent Workflows</div>
-  <h1>Deterministic agent workflows need runtime gates.</h1>
-  <p style="color:var(--muted);">6 min read &middot; For teams moving from one-off Claude Code prompts to repeatable multi-agent runs</p>
-  <div class="tldr"><strong>TL;DR:</strong> Claude Code workflows make orchestration more repeatable by moving control flow into scripts. That is a major step forward, but deterministic orchestration is not deterministic safety. ThumbGate adds pre-action gates, proof requirements, and repeat-failure memory around each workflow run.</div>
-  <h2>The workflow shift is real</h2>
-  <p>Dynamic workflows move agent orchestration out of a fragile chat transcript and into scriptable control flow. That changes the operating model: teams can review the workflow, commit it to git, rerun it, and hand it to another operator without re-explaining the whole plan.</p>
-  <p>The high-value lesson is simple: use code for control flow and use the model for judgment. The workflow script should decide sequence, fan-out, retries, and handoffs. The model should handle the parts that actually require reasoning.</p>
-  <div class="callout">
-    <strong>ThumbGate's angle:</strong> A deterministic workflow still contains nondeterministic agent calls. The control layer has to check every proposed tool action before it mutates state.
-  </div>
-  <h2>Where deterministic workflows still fail</h2>
-  <p>A git-committed workflow can make a run repeatable, but it does not automatically make the run safe. The workflow can still:</p>
-  <ul>
-    <li>Run with stale assumptions about branch, environment, credentials, or allowed files.</li>
-    <li>Spawn multiple subagents that repeat a known bad edit in parallel.</li>
-    <li>Claim completion after a plan step without showing test, CI, screenshot, or deploy evidence.</li>
-    <li>Let a subagent call shell, git, browser, or API tools outside the intended scope.</li>
-    <li>Hide failure behind a successful final summary if the proof artifacts are not required.</li>
-  </ul>
-  <h2>The missing primitive: a workflow run contract</h2>
-  <p>Before a deterministic workflow starts, define the contract the run must obey. The contract should be versioned next to the workflow and evaluated by gates outside the model.</p>
-  <div class="run-contract">
-<pre><code>{
-  "workflow_id": "pricing-surface-fix",
-  "allowed_branches": ["feature/*", "fix/*"],
-  "protected_paths": ["public/pricing.html", "src/api/server.js"],
-  "required_evidence": ["git_diff", "targeted_tests", "link_check"],
-  "blocked_actions": ["git push --force", "npm publish", "deploy production"],
-  "completion_gate": "tests_passed_and_changes_pushed"
-}</code></pre>
-  </div>
-  <p>That contract gives the workflow a boundary. ThumbGate turns the boundary into runtime decisions: allow, warn, block, or require approval.</p>
-  <table class="matrix">
-    <thead>
-      <tr>
-        <th>Workflow layer</th>
-        <th>What it controls</th>
-        <th>ThumbGate gate</th>
-      </tr>
-    </thead>
-    <tbody>
-      <tr>
-        <td>Plan</td>
-        <td>Which tasks and subagents run.</td>
-        <td>Require scope, branch, allowed paths, and done criteria before tools execute.</td>
-      </tr>
-      <tr>
-        <td>Fan-out</td>
-        <td>How many agents work in parallel.</td>
-        <td>Block repeated known-bad actions across subagents before they amplify.</td>
-      </tr>
-      <tr>
-        <td>Tool calls</td>
-        <td>Shell, file writes, git, browser, API, deploy, publish.</td>
-        <td>Evaluate PreToolUse checks before state changes.</td>
-      </tr>
-      <tr>
-        <td>Merge / publish</td>
-        <td>When the run becomes durable.</td>
-        <td>Require tests, link checks, CI status, PR URL, and no unresolved high-risk gates.</td>
-      </tr>
-      <tr>
-        <td>Learning</td>
-        <td>What the next run remembers.</td>
-        <td>Promote thumbs-downs and failed proof checks into prevention rules.</td>
-      </tr>
-    </tbody>
-  </table>
-  <h2>The highest-ROI ThumbGate feature from this trend</h2>
-  <p>The feature to sell is not "we run workflows." Claude Code, Cursor, Codex, and other harnesses will all keep improving orchestration. The ThumbGate feature is <strong>workflow proof gating</strong>: before a workflow claims success, it must prove the contract was satisfied.</p>
-  <ul>
-    <li><strong>Before run:</strong> validate branch, scope, credentials, allowed paths, and budget.</li>
-    <li><strong>During run:</strong> check every tool call against feedback-derived lessons and policy gates.</li>
-    <li><strong>After run:</strong> require evidence artifacts before "done," "merged," "published," or "deployed" claims.</li>
-    <li><strong>Next run:</strong> use thumbs-downs and failed evidence checks to block repeated mistakes earlier.</li>
-  </ul>
-  <div class="callout callout-green">
-    <strong>Buyer demo:</strong> show the same deterministic workflow twice. First run records a blocked risky action. Second run stops the repeat before execution and exports the proof.
-  </div>
-  <h2>Implementation checklist</h2>
-  <ol>
-    <li>Commit workflow scripts and run contracts to git.</li>
-    <li>Run workflow agents on feature branches or isolated worktrees.</li>
-    <li>Route all tool calls through ThumbGate PreToolUse checks.</li>
-    <li>Require proof artifacts before completion claims.</li>
-    <li>Track the headline metric: repeated workflow failures blocked before execution.</li>
-  </ol>
-  <div class="cta-box">
-    <h2 style="color:var(--text);font-size:1.3rem;margin:0 0 8px;">Harden one deterministic workflow</h2>
-    <p>Start with one run contract, one repeated failure, and one proof gate.</p>
-    <div class="cta-install">$ npx thumbgate init</div>
-  </div>
-  <div class="related">
-    <h3>Related articles</h3>
-    <a href="/learn/background-agent-control-layer">Background Agents Need a Control Layer &rarr;</a>
-    <a href="/learn/agentic-enterprise-context-brain">Agentic Enterprise Context Brain &rarr;</a>
-    <a href="/learn/agent-swarms-shared-gates">Agent Swarms: One Gate Layer, Every Model &rarr;</a>
-    <a href="/learn/mcp-pre-action-checks-explained">MCP Pre-Action Checks Explained &rarr;</a>
-  </div>
-</div>
-<div class="sticky-cta">
-  <span style="color:var(--muted)">Try it now:</span>
-  <code>npx thumbgate init</code>
-  <a href="https://github.com/IgorGanapolsky/ThumbGate" target="_blank" rel="noopener">GitHub &rarr;</a>
-</div>
-</body>
-</html>

package/public/learn/feedback-loop-vs-decision-layer.html DELETED Viewed

@@ -1,283 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-<meta charset="UTF-8">
-<meta name="viewport" content="width=device-width, initial-scale=1.0">
-<title>The feedback loop is the product. The PreToolUse hook is its endpoint. - ThumbGate</title>
-<script defer data-domain="thumbgate.ai" src="https://plausible.io/js/script.js"></script>
-<meta name="description" content="ThumbGate is not a PreToolUse hook with feedback bolted on. It is a four-stage feedback-to-enforcement loop — capture the attorney or engineer's vote on any AI answer, store the lesson locally, promote recurring patterns to deterministic rules, then enforce at PreToolUse — where the hook is the endpoint of the loop, not the product. This is why customers buy the loop, not the hook.">
-<meta name="keywords" content="ThumbGate feedback loop, agent governance loop, decision-layer vs action-layer enforcement, thumbs up down AI agent, Thompson Sampling rule promotion, PreToolUse endpoint, lesson DB enforcement">
-<meta property="og:title" content="The feedback loop is the product. The PreToolUse hook is its endpoint.">
-<meta property="og:description" content="Capture vote → store lesson → promote rule → enforce at runtime. ThumbGate is the loop. The hook is one stage of four.">
-<meta property="og:type" content="article">
-<meta property="og:url" content="https://thumbgate.ai/learn/feedback-loop-vs-decision-layer">
-<link rel="canonical" href="https://thumbgate.ai/learn/feedback-loop-vs-decision-layer">
-<link rel="stylesheet" href="/learn/learn.css">
-<script type="application/ld+json">
-{
-  "@context": "https://schema.org",
-  "@type": "TechArticle",
-  "headline": "The feedback loop is the product. The PreToolUse hook is its endpoint.",
-  "description": "Decision-layer governance (prompt rules, AI judge models, human-in-the-loop workflow principles) is necessary but not sufficient. Action-layer enforcement at the PreToolUse hook is the deterministic gate. But neither alone is the product. ThumbGate's product is the four-stage feedback-to-enforcement loop: capture the user's vote on any AI answer, store the lesson, promote recurring patterns to rules, then enforce — closing the loop so the next decision is gated before the next human is ever asked to approve.",
-  "author": {
-    "@type": "Person",
-    "name": "Igor Ganapolsky",
-    "url": "https://github.com/IgorGanapolsky"
-  },
-  "publisher": {
-    "@type": "Organization",
-    "name": "ThumbGate",
-    "url": "https://thumbgate.ai"
-  },
-  "datePublished": "2026-05-27",
-  "dateModified": "2026-05-27",
-  "mainEntityOfPage": "https://thumbgate.ai/learn/feedback-loop-vs-decision-layer",
-  "about": [
-    { "@type": "Thing", "name": "agent governance feedback loop" },
-    { "@type": "Thing", "name": "decision-layer vs action-layer enforcement" },
-    { "@type": "Thing", "name": "deterministic rule promotion" },
-    { "@type": "Thing", "name": "Thompson Sampling for agent rules" }
-  ]
-}
-</script>
-<script type="application/ld+json">
-{
-  "@context": "https://schema.org",
-  "@type": "FAQPage",
-  "mainEntity": [
-    {
-      "@type": "Question",
-      "name": "Is ThumbGate a PreToolUse hook, a feedback collector, or a rule engine?",
-      "acceptedAnswer": {
-        "@type": "Answer",
-        "text": "All three, in a loop. ThumbGate is the four-stage loop: (1) Capture — the user clicks 👍 or 👎 on any AI answer, decision, or proposed tool call; (2) Memory — the feedback record lands in a local lesson DB (SQLite + LanceDB vector index) on the user's infrastructure; (3) Rule promotion — recurring 👎 patterns get promoted to deterministic prevention rules via Thompson Sampling, and recurring 👍 patterns become reinforced routing; (4) Enforcement — the promoted rules fire at the PreToolUse hook before the agent's next proposed tool call executes. The PreToolUse hook is one stage of four. Customers buy the loop, not any single stage."
-      }
-    },
-    {
-      "@type": "Question",
-      "name": "What is decision-layer governance, and why isn't it enough?",
-      "acceptedAnswer": {
-        "@type": "Answer",
-        "text": "Decision-layer governance is anything that asks the model to reason about whether an action is safe: prompt rules embedded in the system prompt, AI 'judge' models that score proposed actions, human-in-the-loop workflow principles, ethics-training modules for the model. All of these can fail in three ways: the model forgets the rule under context compression, the model reasons around the rule as a new edge case, or the model produces output the human approver misses. Sullivan & Cromwell had every form of decision-layer governance — policies, mandatory training, verification requirements — and still filed AI-hallucinated citations with a federal judge in early 2026. Decision-layer governance is necessary. It is not sufficient."
-      }
-    },
-    {
-      "@type": "Question",
-      "name": "What is action-layer enforcement, and why isn't it enough by itself either?",
-      "acceptedAnswer": {
-        "@type": "Answer",
-        "text": "Action-layer enforcement is a runtime gate that inspects the proposed action (a tool call, a shell command, an outbound API request) before it executes and returns allow / warn / block / route-to-human deterministically — no LLM in the decision path. It catches what decision-layer governance misses. But action-layer enforcement alone is a static rule set. It doesn't learn from the team's actual incidents. It doesn't get sharper after each blocked action. It treats every team the same. The piece that makes the gate yours is the feedback loop that promotes your team's specific patterns into the rule set. Action-layer enforcement is necessary. It is not sufficient either."
-      }
-    },
-    {
-      "@type": "Question",
-      "name": "Why does the loop matter more than the hook?",
-      "acceptedAnswer": {
-        "@type": "Answer",
-        "text": "Three reasons. First, the loop encodes your team's specific failure patterns — not generic SOC2 boilerplate, not vendor-shipped rules. Every 👎 your attorney or engineer logs becomes part of your firm's governance. Second, the loop survives model upgrades — a rule promoted from a lesson DB lives in your infrastructure, not in a prompt that the next Claude or Gemini release will reinterpret. Third, the loop turns vendor incidents into competitor moats — Sullivan & Cromwell's hallucination is a one-time embarrassment for them; if their lesson DB had captured the pattern and promoted it to a rule, every subsequent intake at every S&C office would have the gate firing the moment a similar advice-shaped output was proposed. The PreToolUse hook is the moment of enforcement. The loop is what makes the moment intelligent."
-      }
-    },
-    {
-      "@type": "Question",
-      "name": "How does the loop compare to RLHF or fine-tuning the model?",
-      "acceptedAnswer": {
-        "@type": "Answer",
-        "text": "RLHF (Reinforcement Learning from Human Feedback) is decision-layer governance — it adjusts the model's weights so the model is statistically less likely to produce bad output. ThumbGate's loop is the opposite category: it doesn't touch the model. The lesson DB and the promoted rules live outside the model context. A model upgrade resets training-baked safety; rules in the lesson DB survive. RLHF needs millions of examples to shift behavior; one team's 👎 in ThumbGate becomes a rule after a small number of consistent flags (default Thompson Sampling threshold). RLHF is a model-vendor decision; the lesson DB is your team's decision."
-      }
-    }
-  ]
-}
-</script>
-<style>
-  table { width: 100%; border-collapse: collapse; margin: 1rem 0; }
-  th, td { text-align: left; padding: 0.7rem 0.8rem; border-bottom: 1px solid var(--border); vertical-align: top; font-size: 0.92rem; }
-  th { color: var(--cyan); font-weight: 700; }
-  .layer strong { color: var(--green); }
-  .mini-grid { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 1rem; margin: 1.25rem 0; }
-  .mini-card { background: var(--bg-card); border: 1px solid var(--border); border-radius: 8px; padding: 1rem; }
-  .mini-card h3 { margin-top: 0; color: var(--text); }
-  .mini-card p { color: var(--muted); }
-  .loop-stage { border-left: 3px solid var(--cyan); padding: 0.6rem 1rem; margin: 0.75rem 0; background: rgba(34, 211, 238, 0.04); border-radius: 0 6px 6px 0; }
-  .loop-stage strong { color: var(--cyan); display: block; font-size: 0.78rem; text-transform: uppercase; letter-spacing: 0.08em; margin-bottom: 0.2rem; }
-  blockquote { border-left: 3px solid var(--cyan); margin: 1rem 0; padding: 0.5rem 1rem; color: var(--text); font-style: italic; background: rgba(34, 211, 238, 0.05); }
-  .loop-diagram { display: grid; grid-template-columns: 1fr auto 1fr auto 1fr auto 1fr auto; gap: 0.5rem; align-items: stretch; margin: 1.5rem 0 0.5rem; padding: 1.25rem; background: rgba(34, 211, 238, 0.03); border: 1px solid rgba(34, 211, 238, 0.2); border-radius: 10px; position: relative; }
-  .loop-diagram .stage { background: #0f0f11; border: 1px solid rgba(34, 211, 238, 0.4); border-radius: 8px; padding: 0.75rem 0.85rem; display: flex; flex-direction: column; gap: 0.35rem; min-width: 0; }
-  .loop-diagram .stage .num { font-size: 0.7rem; color: var(--cyan); letter-spacing: 0.12em; text-transform: uppercase; font-weight: 600; }
-  .loop-diagram .stage .name { color: var(--text); font-size: 1rem; font-weight: 600; line-height: 1.2; }
-  .loop-diagram .stage .blurb { color: var(--muted); font-size: 0.78rem; line-height: 1.35; }
-  .loop-diagram .arrow { display: flex; align-items: center; justify-content: center; color: var(--cyan); font-size: 1.4rem; line-height: 1; user-select: none; }
-  .loop-diagram .closes { display: flex; align-items: center; justify-content: center; color: var(--green); font-weight: 600; font-size: 0.72rem; letter-spacing: 0.08em; text-transform: uppercase; padding-left: 0.4rem; border-left: 1px dashed rgba(114, 227, 165, 0.4); }
-  .loop-diagram .closes span { writing-mode: vertical-rl; transform: rotate(180deg); }
-  .loop-diagram-caption { font-size: 0.82rem; color: var(--muted); margin: 0.25rem 0 1.25rem; text-align: center; }
-  @media (max-width: 800px) {
-    .loop-diagram { grid-template-columns: 1fr; }
-    .loop-diagram .arrow { transform: rotate(90deg); padding: 0.1rem 0; }
-    .loop-diagram .closes { writing-mode: initial; padding: 0.5rem; border-left: none; border-top: 1px dashed rgba(114, 227, 165, 0.4); justify-content: center; }
-    .loop-diagram .closes span { writing-mode: initial; transform: none; }
-  }
-  @media (max-width: 700px) { .mini-grid { grid-template-columns: 1fr; } }
-</style>
-</head>
-<body>
-<nav>
-  <a href="/" class="brand"><img src="/assets/brand/thumbgate-mark-inline.svg" alt="ThumbGate" class="logo-mark" width="28" height="28"><span class="logo-text">ThumbGate</span></a>
-  <a href="/guide">Setup Guide</a>
-  <a href="/learn">Learn</a>
-  <a href="/dashboard">Dashboard</a>
-  <a href="https://github.com/IgorGanapolsky/ThumbGate" target="_blank" rel="noopener">GitHub</a>
-</nav>
-<div class="container">
-  <div class="breadcrumb"><a href="/learn">Learn</a> / The feedback loop vs the decision layer</div>
-  <h1>The feedback loop is the product. The PreToolUse hook is its endpoint.</h1>
-  <p style="color:var(--muted);">6 min read &middot; For engineering leaders, attorneys, and risk teams deciding how to govern AI agents in their environment</p>
-  <div class="tldr"><strong>TL;DR:</strong> ThumbGate isn't a PreToolUse hook with feedback bolted on. It's a four-stage feedback-to-enforcement loop. Capture the user's 👍/👎 on any AI answer → store the lesson locally → promote recurring patterns to deterministic rules → enforce at PreToolUse. The hook is one stage of four. The loop is the product. Decision-layer governance (prompt rules, AI judges, "human in the loop") is necessary but not sufficient — Sullivan &amp; Cromwell had every form of it and still got sanctioned. Action-layer enforcement alone is a static rule set. The loop is what makes the rule set <em>yours</em>.</div>
-  <h2>Two layers that everyone confuses</h2>
-  <p>Most "AI agent governance" conversations are stuck in one of two camps:</p>
-  <table>
-    <thead>
-      <tr>
-        <th>Layer</th>
-        <th>What it does</th>
-        <th>Why it isn't enough alone</th>
-      </tr>
-    </thead>
-    <tbody>
-      <tr class="layer">
-        <td><strong>Decision-layer</strong></td>
-        <td>Prompt rules embedded in the system prompt. AI judge models that score proposed actions. Human-in-the-loop workflow principles. RLHF training that adjusts model weights toward safe output.</td>
-        <td>The model can forget the rule under context compression, reason around it as a new edge case, or produce output the human approver misses. Decision-layer governance is what Sullivan &amp; Cromwell had when they filed AI-hallucinated citations with a federal judge.</td>
-      </tr>
-      <tr class="layer">
-        <td><strong>Action-layer</strong></td>
-        <td>A runtime gate that inspects the proposed tool call (bash, SQL, file write, MCP call, outbound LLM call) at PreToolUse and returns allow / warn / block / route-to-human deterministically.</td>
-        <td>A static rule set is generic. It doesn't learn from <em>your</em> team's incidents. It doesn't get sharper after each blocked action. Every team gets the same starter pack. The piece that makes the gate <em>yours</em> is missing.</td>
-      </tr>
-    </tbody>
-  </table>
-  <div class="callout">
-    <strong>Both layers are necessary. Neither is sufficient. The product that makes them a system is the loop that connects them.</strong>
-  </div>
-  <h2>The four-stage feedback-to-enforcement loop</h2>
-  <p>ThumbGate is the loop, not the hook. Four stages, all in your environment, all closing the gap between "the user noticed something was wrong" and "the next agent action that pattern matches is gated automatically."</p>
-  <div class="loop-diagram" aria-label="Four-stage feedback-to-enforcement loop">
-    <div class="stage">
-      <span class="num">Stage 1</span>
-      <span class="name">Capture</span>
-      <span class="blurb">Attorney clicks 👍 or 👎 on an AI answer. One click, full context recorded.</span>
-    </div>
-    <div class="arrow" aria-hidden="true">&rarr;</div>
-    <div class="stage">
-      <span class="num">Stage 2</span>
-      <span class="name">Memory</span>
-      <span class="blurb">Local lesson DB (SQLite + LanceDB). Nothing leaves the firm.</span>
-    </div>
-    <div class="arrow" aria-hidden="true">&rarr;</div>
-    <div class="stage">
-      <span class="num">Stage 3</span>
-      <span class="name">Rule promotion</span>
-      <span class="blurb">Recurring 👎 patterns promote to deterministic, human-editable rules.</span>
-    </div>
-    <div class="arrow" aria-hidden="true">&rarr;</div>
-    <div class="stage">
-      <span class="num">Stage 4</span>
-      <span class="name">Enforcement</span>
-      <span class="blurb">Rules fire pre-action: allow, warn, block, or route to attorney.</span>
-    </div>
-    <div class="closes" aria-label="Loop closes back to capture"><span>Loop closes &rarr; back to capture</span></div>
-  </div>
-  <p class="loop-diagram-caption">All four stages run inside your environment. The hook is just the visible endpoint of stage 4.</p>
-  <div class="loop-stage">
-    <strong>Stage 1 &mdash; Capture</strong>
-    The user (attorney, engineer, risk officer) reviews an AI answer &mdash; a Claude for Legal drafted clause, a Cursor proposed refactor, a Claude Code shell command, a Codex agent's research summary. They click 👍 (the answer was good) or 👎 (the answer was wrong, unauthorized, or unsafe). One click. The record stores the context, what worked or went wrong, and what should change next time.
-  </div>
-  <div class="loop-stage">
-    <strong>Stage 2 &mdash; Memory</strong>
-    The feedback record lands in a local lesson DB on the team's infrastructure &mdash; SQLite with FTS5 for keyword/lexical recall, plus LanceDB for vector/semantic recall. Wins, mistakes, and edge cases all stored. The DB is searchable: when a new agent task matches a prior pattern, the relevant lessons surface as context before the agent answers. Nothing leaves the team's perimeter.
-  </div>
-  <div class="loop-stage">
-    <strong>Stage 3 &mdash; Rule promotion</strong>
-    When a 👎 pattern recurs across distinct sessions, Thompson Sampling promotes it from a one-off lesson to a deterministic prevention rule. Wins reinforce preferred routing the same way. The rule is human-readable and editable &mdash; the team's ethics or platform lead can audit, soften, or override it. The promotion logic is deterministic, not a black box.
-  </div>
-  <div class="loop-stage">
-    <strong>Stage 4 &mdash; Enforcement</strong>
-    Promoted rules fire at the PreToolUse hook before the agent's next proposed tool call executes. Allow, warn, block, or route-to-human, with an artifact-level audit log (rule ID, version, matched pattern, audit ID, ISO 27001 control mapping). The user's vote from Stage 1 is now an enforced constraint that fires deterministically before any human is asked to approve again. The loop closes.
-  </div>
-  <h2>Why the loop matters more than any single stage</h2>
-  <div class="mini-grid">
-    <div class="mini-card">
-      <h3>It encodes your patterns, not vendor boilerplate</h3>
-      <p>Generic governance rules ("don't push to main") are table stakes. The rules that actually matter for your firm or your team are the ones derived from your incidents &mdash; the specific UPL phrasing your associates flag, the matter-number conventions your privilege review uses, the deploy commands your platform team blocks. The loop encodes those automatically.</p>
-    </div>
-    <div class="mini-card">
-      <h3>It survives model upgrades and prompt resets</h3>
-      <p>A rule in the prompt vanishes when the next Claude or Gemini release reinterprets context. A rule promoted from your lesson DB lives in your infrastructure, separate from any model vendor. Model upgrades reset training-baked safety; the lesson DB doesn't.</p>
-    </div>
-    <div class="mini-card">
-      <h3>It turns one incident into permanent prevention</h3>
-      <p>Sullivan &amp; Cromwell's hallucination was a one-time embarrassment for them. If their lesson DB had captured the pattern and promoted it to a rule, every subsequent intake across every S&amp;C office would have the gate firing the moment a similar advice-shaped output was proposed. The first 👎 becomes the rule that catches the next ten cases.</p>
-    </div>
-    <div class="mini-card">
-      <h3>It composes with model providers, not against them</h3>
-      <p>Anthropic's Claude for Legal, Harvey's BigLaw assistants, Cursor's agent mode, OpenAI's Codex CLI &mdash; all of these are decision-layer products. The loop runs underneath them, agnostic to which vendor generated the proposed action. You don't pick a vendor and live with their generic safety; you pick the vendor for capability and own the safety yourself.</p>
-    </div>
-  </div>
-  <h2>How this differs from RLHF and other "model-side" approaches</h2>
-  <p>RLHF (Reinforcement Learning from Human Feedback) is decision-layer governance &mdash; it adjusts the model's weights so the model is statistically less likely to produce bad output. ThumbGate's loop is the opposite category. It doesn't touch the model. The lesson DB and the promoted rules live outside the model context.</p>
-  <table>
-    <thead>
-      <tr><th>Property</th><th>RLHF / model fine-tuning</th><th>ThumbGate feedback loop</th></tr>
-    </thead>
-    <tbody>
-      <tr><td><strong>Where the change lives</strong></td><td>Inside the model weights</td><td>Outside the model, in your lesson DB</td></tr>
-      <tr><td><strong>Who controls it</strong></td><td>Model vendor</td><td>Your team</td></tr>
-      <tr><td><strong>How many examples to shift behavior</strong></td><td>Millions</td><td>Default Thompson Sampling threshold &mdash; a small number of consistent 👎</td></tr>
-      <tr><td><strong>What happens at model upgrade</strong></td><td>Training-baked safety partially resets</td><td>Rules survive; loop continues</td></tr>
-      <tr><td><strong>Auditability</strong></td><td>Opaque weights; explainability is best-effort</td><td>Rule ID + version + matched pattern + audit ID, deterministic</td></tr>
-    </tbody>
-  </table>
-  <blockquote>The loop is the product. The hook is the moment of enforcement. The DB is the memory. The promotion is the learning. Without all four, "agent governance" is either a prompt rule or a static gate &mdash; both useful, neither sufficient.</blockquote>
-  <h2>What to do with this if you're evaluating ThumbGate</h2>
-  <ol>
-    <li><strong>Don't ask "does it have PreToolUse hooks?"</strong> &mdash; every governance tool will say yes. Ask <em>"does the gate get sharper after each incident, automatically, in our environment?"</em></li>
-    <li><strong>Don't ask "what rules ship out of the box?"</strong> &mdash; the rules that matter are the ones derived from your team's incidents. Ask <em>"how does a 👎 from one of our reviewers become a rule that fires for everyone next week?"</em></li>
-    <li><strong>Don't ask "does it work with Claude?"</strong> &mdash; ask <em>"does it work with whichever vendor we pick next quarter?"</em> The loop is vendor-agnostic by design.</li>
-  </ol>
-  <div class="cta-box">
-    <h2 style="color:var(--text);font-size:1.3rem;margin:0 0 8px;">Install the loop, not just the gate</h2>
-    <p>The PreToolUse hook is the endpoint. The loop is what makes it learn. Two minutes to install.</p>
-    <div class="cta-install">$ npx thumbgate init</div>
-  </div>
-  <div class="related">
-    <h3>Related articles</h3>
-    <a href="/learn/background-agent-control-layer">Background Agent Control Layer &rarr;</a>
-    <a href="/learn/ac-dc-runtime-enforcement">AC/DC Runtime Enforcement &rarr;</a>
-    <a href="/learn/mcp-pre-action-checks-explained">MCP Pre-Action Checks Explained &rarr;</a>
-    <a href="/compare/anthropic-containment">ThumbGate vs Anthropic Containment &rarr;</a>
-  </div>
-</div>
-<div class="sticky-cta">
-  <span style="color:var(--muted)">Try it now:</span>
-  <code>npx thumbgate init</code>
-  <a href="https://github.com/IgorGanapolsky/ThumbGate" target="_blank" rel="noopener">GitHub &rarr;</a>
-</div>
-</body>
-</html>