thumbgate 1.4.3 → 1.4.5

package/public/js/buyer-intent.js

@@ -1,252 +0,0 @@
-(function(global) {
-  var BUYER_EMAIL_STORAGE_KEY = 'thumbgateBuyerEmail';
-  var CHECKOUT_LINK_SELECTOR = 'a[href*="/checkout/pro"]';
-  var BUYER_EMAIL_SELECTOR = '[data-buyer-email]';
-
-  function normalizeBuyerEmail(value) {
-    return String(value || '').trim().toLowerCase();
-  }
-
-  function isValidBuyerEmail(value) {
-    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(normalizeBuyerEmail(value));
-  }
-
-  function getStorage() {
-    return global.localStorage && typeof global.localStorage.getItem === 'function'
-      ? global.localStorage
-      : null;
-  }
-
-  function getStoredBuyerEmail() {
-    var storage = getStorage();
-    if (!storage) {
-      return '';
-    }
-    try {
-      return normalizeBuyerEmail(storage.getItem(BUYER_EMAIL_STORAGE_KEY));
-    } catch (_error) {
-      return '';
-    }
-  }
-
-  function storeBuyerEmail(email) {
-    var storage = getStorage();
-    if (!storage) {
-      return false;
-    }
-    try {
-      storage.setItem(BUYER_EMAIL_STORAGE_KEY, normalizeBuyerEmail(email));
-      return true;
-    } catch (_error) {
-      return false;
-    }
-  }
-
-  function resolveCheckoutUrl(urlValue, email) {
-    var origin = global.location && global.location.origin
-      ? global.location.origin
-      : 'https://thumbgate.invalid';
-    var checkoutUrl = new URL(String(urlValue || '/checkout/pro'), origin);
-    if (checkoutUrl.origin !== origin || checkoutUrl.pathname !== '/checkout/pro') {
-      checkoutUrl = new URL('/checkout/pro', origin);
-    }
-    if (isValidBuyerEmail(email)) {
-      checkoutUrl.searchParams.set('customer_email', normalizeBuyerEmail(email));
-    } else {
-      checkoutUrl.searchParams.delete('customer_email');
-    }
-    return checkoutUrl;
-  }
-
-  function getCheckoutLinks(selector) {
-    if (!global.document || typeof global.document.querySelectorAll !== 'function') {
-      return [];
-    }
-    return Array.from(global.document.querySelectorAll(selector || CHECKOUT_LINK_SELECTOR));
-  }
-
-  function getBaseCheckoutHref(link) {
-    if (!link.dataset.baseHref) {
-      link.dataset.baseHref = link.getAttribute('href') || link.href || '/checkout/pro';
-    }
-    return link.dataset.baseHref;
-  }
-
-  function applyBuyerEmailToCheckoutLinks(email, selector) {
-    getCheckoutLinks(selector).forEach(function(link) {
-      link.href = resolveCheckoutUrl(getBaseCheckoutHref(link), email).toString();
-    });
-  }
-
-  function hydrateBuyerEmailInputs(email, selector) {
-    if (!global.document || typeof global.document.querySelectorAll !== 'function') {
-      return;
-    }
-    Array.from(global.document.querySelectorAll(selector || BUYER_EMAIL_SELECTOR)).forEach(function(input) {
-      if (!input.value) {
-        input.value = normalizeBuyerEmail(email);
-      }
-    });
-  }
-
-  function getNewsletterStatusElement(form) {
-    if (!form) {
-      return null;
-    }
-    return form.querySelector('[data-newsletter-status]')
-      || (form.parentElement ? form.parentElement.querySelector('[data-newsletter-status]') : null);
-  }
-
-  function setNewsletterStatus(form, message, ok) {
-    var statusEl = getNewsletterStatusElement(form);
-    if (!statusEl) {
-      return;
-    }
-    statusEl.textContent = message;
-    statusEl.style.color = ok ? 'var(--cyan)' : 'var(--red, #f87171)';
-  }
-
-  async function submitNewsletterSignup(email, form) {
-    var action = form && form.action ? form.action : '/api/newsletter';
-    var response = await fetch(action, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/x-www-form-urlencoded',
-        Accept: 'application/json',
-        'X-Requested-With': 'fetch',
-      },
-      body: new URLSearchParams({ email: normalizeBuyerEmail(email) }).toString(),
-      credentials: 'same-origin',
-    });
-    if (!response.ok) {
-      var errorMessage = 'Unable to save your email right now.';
-      try {
-        var errorBody = await response.json();
-        if (errorBody && errorBody.error) {
-          errorMessage = errorBody.error;
-        }
-      } catch (_error) {
-        // Keep the default error message when the response is not JSON.
-      }
-      throw new Error(errorMessage);
-    }
-    try {
-      return await response.json();
-    } catch (_error) {
-      return { accepted: true, duplicate: false };
-    }
-  }
-
-  function trackEvent(eventName, props) {
-    if (typeof global.plausible === 'function') {
-      global.plausible(eventName, { props: props || {} });
-    }
-  }
-
-  function getEmailFromInput(input) {
-    return normalizeBuyerEmail(input && input.value);
-  }
-
-  function initializeBuyerIntent(options) {
-    var settings = options || {};
-    var storedEmail = getStoredBuyerEmail();
-    if (storedEmail) {
-      hydrateBuyerEmailInputs(storedEmail, settings.emailSelector);
-      applyBuyerEmailToCheckoutLinks(storedEmail, settings.checkoutSelector);
-    }
-
-    if (!global.document || typeof global.document.querySelectorAll !== 'function') {
-      return;
-    }
-
-    Array.from(global.document.querySelectorAll(settings.formSelector || '[data-newsletter-form]')).forEach(function(form) {
-      form.addEventListener('submit', async function(event) {
-        event.preventDefault();
-        var input = form.querySelector(settings.formEmailSelector || 'input[name="email"]');
-        var email = getEmailFromInput(input);
-        if (!isValidBuyerEmail(email)) {
-          setNewsletterStatus(form, settings.invalidEmailMessage || 'Enter a valid work email.', false);
-          if (input) {
-            input.focus();
-          }
-          return;
-        }
-
-        storeBuyerEmail(email);
-        hydrateBuyerEmailInputs(email, settings.emailSelector);
-        applyBuyerEmailToCheckoutLinks(email, settings.checkoutSelector);
-
-        try {
-          var result = await submitNewsletterSignup(email, form);
-          var successMessage = result && result.duplicate
-            ? (settings.duplicateMessage || 'You are already on the list. Checkout on this device is now prefilled.')
-            : (settings.successMessage || 'Saved. We will keep checkout prefilled on this device.');
-          setNewsletterStatus(form, successMessage, true);
-          trackEvent('newsletter_signup', {
-            page: form.dataset.page || settings.page || 'homepage',
-            intent: form.dataset.intent || settings.intent || 'buyer_follow_up',
-          });
-        } catch (error) {
-          setNewsletterStatus(
-            form,
-            error && error.message ? error.message : 'Unable to save your email right now.',
-            false
-          );
-        }
-      });
-    });
-  }
-
-  function initializeEmailCheckoutButtons(options) {
-    var settings = options || {};
-    if (!global.document || typeof global.document.querySelectorAll !== 'function') {
-      return;
-    }
-
-    Array.from(global.document.querySelectorAll(settings.buttonSelector || '.btn-email-checkout')).forEach(function(button) {
-      button.addEventListener('click', async function() {
-        var form = button.closest('form');
-        var input = form ? form.querySelector(settings.formEmailSelector || 'input[name="email"]') : null;
-        var email = getEmailFromInput(input) || getStoredBuyerEmail();
-        if (!isValidBuyerEmail(email)) {
-          setNewsletterStatus(form, settings.invalidCheckoutMessage || 'Enter a valid work email before checkout.', false);
-          if (input) {
-            input.focus();
-          }
-          return;
-        }
-
-        storeBuyerEmail(email);
-        hydrateBuyerEmailInputs(email, settings.emailSelector);
-        applyBuyerEmailToCheckoutLinks(email, settings.checkoutSelector);
-        trackEvent(settings.eventName || 'pro_checkout_email_start', settings.eventProps || { page: 'pro', intent: 'checkout' });
-
-        try {
-          await submitNewsletterSignup(email, form);
-        } catch (_error) {
-          // Continue to checkout even if signup persistence fails.
-        }
-
-        var checkoutLink = global.document.querySelector(settings.checkoutLinkSelector || '.btn-pro-checkout');
-        if (checkoutLink) {
-          global.location.assign(checkoutLink.href);
-        }
-      });
-    });
-  }
-
-  global.ThumbGateBuyerIntent = {
-    normalizeBuyerEmail: normalizeBuyerEmail,
-    isValidBuyerEmail: isValidBuyerEmail,
-    getStoredBuyerEmail: getStoredBuyerEmail,
-    storeBuyerEmail: storeBuyerEmail,
-    resolveCheckoutUrl: resolveCheckoutUrl,
-    applyBuyerEmailToCheckoutLinks: applyBuyerEmailToCheckoutLinks,
-    hydrateBuyerEmailInputs: hydrateBuyerEmailInputs,
-    setNewsletterStatus: setNewsletterStatus,
-    submitNewsletterSignup: submitNewsletterSignup,
-    initializeBuyerIntent: initializeBuyerIntent,
-    initializeEmailCheckoutButtons: initializeEmailCheckoutButtons,
-    trackEvent: trackEvent,
-  };
-})(globalThis);

package/public/learn/agent-harness-pattern.html

@@ -1,180 +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 Agent Harness Pattern: Why Your AI Needs a Seatbelt — ThumbGate</title>
-<script defer data-domain="thumbgate-production.up.railway.app" src="https://plausible.io/js/script.js"></script>
-<meta name="description" content="Tsinghua researchers formalized agent harnesses as first-class objects with contracts, verification gates, and durable state. ThumbGate implements this pattern today.">
-<meta name="keywords" content="agent harness pattern, natural language agent harness, NLAH, AI agent safety, pre-action gates, verification gates, agent contracts, ThumbGate, MCP hooks">
-<meta property="og:title" content="The Agent Harness Pattern: Why Your AI Needs a Seatbelt">
-<meta property="og:description" content="Academic research meets production code. How the natural-language agent harness pattern maps to real pre-action gates.">
-<meta property="og:type" content="article">
-<meta property="og:url" content="https://thumbgate-production.up.railway.app/learn/agent-harness-pattern">
-<link rel="canonical" href="https://thumbgate-production.up.railway.app/learn/agent-harness-pattern">
-
-<script type="application/ld+json">
-{
-  "@context": "https://schema.org",
-  "@type": "TechArticle",
-  "headline": "The Agent Harness Pattern: Why Your AI Needs a Seatbelt",
-  "description": "How the natural-language agent harness pattern from academic research maps to real pre-action gates you can ship today.",
-  "author": {
-    "@type": "Person",
-    "name": "Igor Ganapolsky",
-    "url": "https://github.com/IgorGanapolsky"
-  },
-  "publisher": {
-    "@type": "Organization",
-    "name": "ThumbGate",
-    "url": "https://thumbgate-production.up.railway.app"
-  },
-  "datePublished": "2026-04-02",
-  "dateModified": "2026-04-02",
-  "mainEntityOfPage": "https://thumbgate-production.up.railway.app/learn/agent-harness-pattern",
-  "about": [
-    {"@type": "Thing", "name": "agent harness pattern"},
-    {"@type": "Thing", "name": "natural language agent harness"},
-    {"@type": "Thing", "name": "AI agent verification"}
-  ]
-}
-</script>
-
-<link rel="stylesheet" href="/learn/learn.css">
-<style>
-  table { width: 100%; border-collapse: collapse; margin: 1rem 0; }
-  th, td { text-align: left; padding: 0.6rem 0.8rem; border-bottom: 1px solid var(--border); font-size: 0.9rem; }
-  th { color: var(--cyan); font-weight: 600; }
-  .mapping-row td:first-child { color: var(--green); font-weight: 500; }
-</style>
-</head>
-<body>
-
-<nav>
-  <a href="/" class="brand">👍👎 ThumbGate</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> / Agent Harness Pattern</div>
-  <h1>The Agent Harness Pattern: Why Your AI Needs a Seatbelt</h1>
-  <p style="color:var(--muted);">5 min read &middot; Research deep-dive for developers shipping AI agents in production</p>
-
-  <div class="tldr"><strong>TL;DR:</strong> Tsinghua researchers proved that AI agents need harnesses — contracts, verification gates, and durable state. ThumbGate is a production implementation you can ship today.</div>
-
-  <h2>The problem: agents act faster than you can review</h2>
-  <p>AI coding agents can write, commit, and deploy code in seconds. The gap between "agent decides to act" and "irreversible damage" is measured in milliseconds. Prompt instructions alone cannot close that gap because they live inside the same context the agent can override.</p>
-  <p>Researchers at Tsinghua University formalized this problem in their work on Natural-Language Agent Harnesses (NLAH). Their key insight: the safety layer must be <strong>external to the agent</strong>, treated as a first-class object with its own contracts, verification logic, and persistent state.</p>
-
-  <div class="callout">
-    <strong>The core idea:</strong> An agent harness is not a prompt. It is a runtime layer that sits between the agent's intent and the outside world, enforcing contracts that the agent cannot bypass.
-  </div>
-
-  <h2>Four components of an agent harness</h2>
-  <p>The NLAH framework defines four components that any production-grade harness needs. Here is how each maps to a concrete implementation in ThumbGate:</p>
-
-  <table>
-    <thead>
-      <tr>
-        <th>NLAH Component</th>
-        <th>What It Does</th>
-        <th>ThumbGate Implementation</th>
-      </tr>
-    </thead>
-    <tbody>
-      <tr class="mapping-row">
-        <td>Contracts</td>
-        <td>Formal rules that define what the agent must not do</td>
-        <td>Prevention rules in <code>prevention-rules.md</code> — auto-generated from thumbs-down feedback</td>
-      </tr>
-      <tr class="mapping-row">
-        <td>Verification Gates</td>
-        <td>Checkpoints that intercept actions before execution</td>
-        <td>PreToolUse hooks — intercept every tool call, match against gates, block or allow</td>
-      </tr>
-      <tr class="mapping-row">
-        <td>Durable State</td>
-        <td>Persistent memory that survives across sessions</td>
-        <td>SQLite+FTS5 lesson database — feedback, memories, and rules persist and are searchable</td>
-      </tr>
-      <tr class="mapping-row">
-        <td>Adapters</td>
-        <td>Platform-specific connectors for different agent runtimes</td>
-        <td>MCP server + adapters for Claude Code, Cursor, Codex, Gemini, Amp, OpenCode</td>
-      </tr>
-    </tbody>
-  </table>
-
-  <h2>Why contracts beat prompt rules</h2>
-  <p>A prompt rule says: "Do not force-push to main." An agent can reason around that, reinterpret it, or simply lose it in a long context window.</p>
-  <p>A contract says: if the tool call is <code>Bash</code> and the command matches <code>git push.*--force</code> targeting <code>main</code>, return <code>{"decision": "block"}</code>. The agent never executes the command. There is nothing to reason around.</p>
-
-  <div class="callout callout-red">
-    <strong>Prompt rules fail silently.</strong> When a prompt rule is violated, you only find out after the damage is done. A verification gate fails loudly — the agent receives a block response and must adapt.
-  </div>
-
-  <h2>Verification gates in practice</h2>
-  <p>Every time your AI agent calls a tool — running a shell command, writing a file, making an API call — a PreToolUse hook fires. ThumbGate checks the call against your gates:</p>
-
-  <ol>
-    <li><strong>Pattern match:</strong> Does the tool name and arguments match any prevention rule?</li>
-    <li><strong>Thompson Sampling:</strong> For rules with uncertain severity, use multi-armed bandit sampling to decide block vs. warn</li>
-    <li><strong>Decision:</strong> Block (hard stop), warn (let agent reconsider), or allow (no match)</li>
-    <li><strong>Feedback loop:</strong> The decision is logged. Thumbs-up/down on outcomes refines future gates.</li>
-  </ol>
-
-  <p>This is the verification gate pattern from the NLAH framework, running in production today.</p>
-
-  <h2>Durable state: memory that survives sessions</h2>
-  <p>One of the NLAH paper's strongest arguments is that agent harnesses need persistent state. An agent that forgets its mistakes between sessions will repeat them.</p>
-  <p>ThumbGate stores every feedback event in a SQLite database with full-text search (FTS5). When a new session starts, the agent's context is assembled from relevant past lessons — not the entire history, but the lessons most similar to the current task.</p>
-
-  <div class="callout callout-green">
-    <strong>The feedback loop closes itself:</strong> You thumbs-down a mistake → a prevention rule is generated → the gate blocks the mistake next time → the agent adapts → you thumbs-up the adaptation → the rule is reinforced.
-  </div>
-
-  <h2>Adapters: one harness, many agents</h2>
-  <p>The NLAH framework emphasizes platform independence. A harness should work across different agent runtimes without rewriting the safety logic.</p>
-  <p>ThumbGate achieves this through the Model Context Protocol (MCP). Any agent that speaks MCP — Claude Code, Cursor, Codex, Gemini, Amp, OpenCode — connects to the same ThumbGate server and gets the same gates. Write your rules once, enforce everywhere.</p>
-
-  <h2>From research to production in two minutes</h2>
-  <p>The NLAH framework describes what an agent harness <em>should</em> be. ThumbGate is what it looks like when you ship one:</p>
-
-  <pre><code>npx thumbgate init</code></pre>
-
-  <p>That single command sets up:</p>
-  <ul>
-    <li>A PreToolUse hook that intercepts every tool call</li>
-    <li>A SQLite+FTS5 lesson database for durable state</li>
-    <li>Prevention rules generated from your feedback</li>
-    <li>Thompson Sampling for probabilistic gate decisions</li>
-    <li>MCP server adapters for your agent runtime</li>
-  </ul>
-
-  <p>You are not writing safety rules from scratch. You are thumbs-downing mistakes and letting the harness learn.</p>
-
-  <div class="cta-box">
-    <h2 style="color:var(--text);font-size:1.3rem;margin:0 0 8px;">Ship the harness pattern today</h2>
-    <p>One command. Works with Claude Code, Cursor, Codex, Gemini, Amp, and any MCP agent.</p>
-    <div class="cta-install">$ npx thumbgate init</div>
-  </div>
-
-  <div class="related">
-    <h3>Related articles</h3>
-    <a href="/learn/mcp-pre-action-gates-explained">MCP Pre-Action Gates Explained →</a>
-    <a href="/learn/stop-ai-agent-force-push">How to Stop AI Agents From Force-Pushing to Main →</a>
-    <a href="/learn/vibe-coding-safety-net">The Vibe Coding Safety Net You Are Missing →</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/ai-agent-persistent-memory.html

@@ -1,203 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-<meta charset="UTF-8">
-<meta name="viewport" content="width=device-width, initial-scale=1.0">
-<title>How to Give Your AI Coding Agent Persistent Memory Across Sessions — ThumbGate</title>
-<script defer data-domain="thumbgate-production.up.railway.app" src="https://plausible.io/js/script.js"></script>
-<meta name="description" content="AI coding agents forget everything when a session ends. Learn how to give Claude Code, Cursor, Codex, and Gemini persistent memory using an MCP memory server that survives restarts.">
-<meta name="keywords" content="ai agent memory, persistent memory, claude code memory, cursor agent memory, MCP memory server, session persistence, agent context, episodic memory, semantic memory">
-<meta property="og:title" content="How to Give Your AI Coding Agent Persistent Memory Across Sessions">
-<meta property="og:description" content="Context windows are ephemeral. Real memory persists. Here is how to build durable memory for any MCP-compatible AI coding agent.">
-<meta property="og:type" content="article">
-<meta property="og:url" content="https://thumbgate-production.up.railway.app/learn/ai-agent-persistent-memory">
-<link rel="canonical" href="https://thumbgate-production.up.railway.app/learn/ai-agent-persistent-memory">
-
-<script type="application/ld+json">
-{
-  "@context": "https://schema.org",
-  "@type": "TechArticle",
-  "headline": "How to Give Your AI Coding Agent Persistent Memory Across Sessions",
-  "description": "AI coding agents forget everything when a session ends. Learn how to give Claude Code, Cursor, Codex, and Gemini persistent memory using an MCP memory server that survives restarts.",
-  "author": {
-    "@type": "Person",
-    "name": "Igor Ganapolsky",
-    "url": "https://github.com/IgorGanapolsky"
-  },
-  "publisher": {
-    "@type": "Organization",
-    "name": "ThumbGate",
-    "url": "https://thumbgate-production.up.railway.app"
-  },
-  "datePublished": "2026-04-02",
-  "dateModified": "2026-04-02",
-  "mainEntityOfPage": "https://thumbgate-production.up.railway.app/learn/ai-agent-persistent-memory",
-  "about": [
-    {"@type": "Thing", "name": "ai agent memory"},
-    {"@type": "Thing", "name": "persistent memory"},
-    {"@type": "Thing", "name": "MCP memory server"},
-    {"@type": "Thing", "name": "session persistence"}
-  ]
-}
-</script>
-
-<link rel="stylesheet" href="/learn/learn.css">
-<style>
-  table { width: 100%; border-collapse: collapse; margin: 1rem 0; }
-  th, td { text-align: left; padding: 0.6rem 0.8rem; border-bottom: 1px solid var(--border); font-size: 0.9rem; }
-  th { color: var(--cyan); font-weight: 600; }
-  .memory-row td:first-child { color: var(--green); font-weight: 500; }
-</style>
-</head>
-<body>
-
-<nav>
-  <a href="/" class="brand">👍👎 ThumbGate</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> / AI Agent Persistent Memory</div>
-  <h1>How to Give Your AI Coding Agent Persistent Memory Across Sessions</h1>
-  <p style="color:var(--muted);">6 min read &middot; For developers using Claude Code, Cursor, Codex, or Gemini who are tired of re-explaining context every session</p>
-
-  <div class="tldr"><strong>TL;DR:</strong> Your AI agent forgets everything between sessions. Give it a SQLite+FTS5 memory that stores lessons, retrieves relevant context, and blocks known-bad actions automatically.</div>
-
-  <h2>The problem: agents forget everything when you close the tab</h2>
-  <p>You spend twenty minutes explaining your codebase to your AI coding agent. You tell it about the monorepo structure, the deployment conventions, the one branch it must never force-push to. The session ends. You come back tomorrow and it has no memory of any of it.</p>
-  <p>You are not doing anything wrong. This is how context windows work. Every session starts with a blank slate. The agent has no continuity of experience — no record of past mistakes, no accumulated knowledge of your project, no recollection of the rules you established last week.</p>
-  <p>The frustration is real and widespread. Developers using Claude Code, Cursor, Codex, and Gemini all hit the same wall. The agents are capable — they just cannot remember.</p>
-
-  <div class="callout">
-    <strong>The distinction that matters:</strong> A context window holds information for one session. Memory holds information across sessions. Most agents have the former. Almost none have the latter by default.
-  </div>
-
-  <h2>Why context windows are not memory</h2>
-  <p>Context windows are large and getting larger. That solves a different problem. A big context window means the agent can reason over more information at once within a single session. It does not mean that information survives when the session ends.</p>
-  <p>Think of the difference this way: a context window is RAM — fast, capacious, gone when the power cuts. Memory is disk — slower to query, but persistent. You need both. Right now, AI coding agents only ship with RAM.</p>
-  <p>The consequences compound over time. An agent with no persistent memory will:</p>
-  <ul>
-    <li>Repeat mistakes it made last week because it has no record of them</li>
-    <li>Re-ask you for project conventions it has already learned once</li>
-    <li>Ignore prevention rules you painstakingly wrote into a prompt — because that prompt is gone</li>
-    <li>Treat every session as if it is the first day on the job</li>
-  </ul>
-  <p>Stuffing facts into a <code>CLAUDE.md</code> file helps, but it is a manual workaround. You are the memory. You remember what to put in the file. You update it when things change. That is not a solution — it is delegation of a machine problem back to a human.</p>
-
-  <div class="callout callout-red">
-    <strong>The hidden cost:</strong> Re-explaining context is not just annoying. Every token you spend re-establishing what the agent already knew is a token not spent on the actual task. And re-explained rules are still just prompt rules — the agent can reason around them.
-  </div>
-
-  <h2>Three types of agent memory</h2>
-  <p>Cognitive science distinguishes several memory types. The same taxonomy maps cleanly onto what AI coding agents need. Here is how each type works and what it looks like in practice:</p>
-
-  <table>
-    <thead>
-      <tr>
-        <th>Memory Type</th>
-        <th>What It Stores</th>
-        <th>Concrete Example</th>
-      </tr>
-    </thead>
-    <tbody>
-      <tr class="memory-row">
-        <td>Episodic</td>
-        <td>Records of specific past events — what happened, when, and what the outcome was</td>
-        <td>The agent tried to force-push to main. You gave thumbs-down. That event is stored with context, timestamp, and failure description.</td>
-      </tr>
-      <tr class="memory-row">
-        <td>Semantic</td>
-        <td>Generalised knowledge extracted from episodes — rules, patterns, facts about the world</td>
-        <td>From multiple thumbs-down events, the system derives: "force-pushing to main causes broken deploys in this repo." That becomes a prevention rule.</td>
-      </tr>
-      <tr class="memory-row">
-        <td>Procedural</td>
-        <td>Encoded behaviours — gates that fire before actions without requiring the agent to reason about them</td>
-        <td>A PreToolUse hook that checks every <code>git push</code> command against the prevention rule and blocks the dangerous pattern automatically.</td>
-      </tr>
-    </tbody>
-  </table>
-
-  <p>Most "persistent memory" proposals for AI agents stop at episodic: they store a log of past conversations. That is useful, but insufficient. The signal gets diluted in a sea of raw events. What agents need is the full pipeline: episodes promote to semantic rules, semantic rules compile into procedural gates.</p>
-
-  <h2>How ThumbGate implements persistent memory</h2>
-  <p>ThumbGate is built around this three-tier memory architecture. Here is each layer in concrete terms.</p>
-
-  <h3>Episodic layer: the feedback log</h3>
-  <p>Every thumbs-up or thumbs-down you give an agent action is written to a structured feedback log. Each entry captures the tool call that was made, the context at the time, what worked or went wrong, and any tags you add. The log is append-only and survives across sessions.</p>
-  <p>In the current Claude auto-capture hook, a vague thumbs-down can borrow up to 8 prior recorded entries plus the failed tool call before promotion. Accepted feedback also opens a linked 60-second follow-up session so later corrections stay attached to the same memory trace instead of fragmenting into duplicates.</p>
-
-  <pre><code># Thumbs-down: record a specific failure
-node .claude/scripts/feedback/capture-feedback.js \
-  --feedback=down \
-  --context="deploying to production" \
-  --what-went-wrong="agent ran db migration without backup" \
-  --what-to-change="always checkpoint before schema changes" \
-  --tags="database,migrations,safety"</code></pre>
-
-  <p>You do not need to write this manually for every interaction. The MCP server captures tool calls automatically. Manual feedback is for adding nuance that the agent could not observe on its own.</p>
-
-  <h3>Semantic layer: the lesson database</h3>
-  <p>Raw feedback events are processed into a SQLite database with full-text search (FTS5). This is not a flat file — it is a queryable knowledge store. When a new session starts, the system retrieves lessons relevant to the current task by similarity, not by recency.</p>
-  <p>The FTS5 index means retrieval is fast even as the database grows. You are not loading the entire history into context. You are loading the lessons most likely to matter right now. That is the difference between a knowledge base and a memory dump.</p>
-
-  <h3>Procedural layer: prevention rules and gates</h3>
-  <p>Promoted lessons generate prevention rules in <code>prevention-rules.md</code>. Rules are not prompt instructions — they are checked by a PreToolUse hook that fires before every tool call. The agent cannot reason around a gate. The gate runs outside the agent's context.</p>
-
-  <div class="callout callout-green">
-    <strong>The promotion pipeline:</strong> Thumbs-down event &rarr; feedback log entry &rarr; lesson promoted to SQLite &rarr; prevention rule generated &rarr; PreToolUse gate active for every future session, with no additional setup.
-  </div>
-
-  <h2>Thompson Sampling for memory-informed decisions</h2>
-  <p>Not every prevention rule has the same confidence level. A rule derived from one thumbs-down event is weaker than a rule reinforced by a dozen. ThumbGate uses Thompson Sampling — a multi-armed bandit algorithm — to handle this uncertainty.</p>
-  <p>For each gate, the system maintains a Beta distribution over outcomes. As thumbs-up and thumbs-down feedback accumulates, the distribution tightens. A gate with high confidence becomes a hard block. A gate still gathering signal issues a warning and lets the agent reconsider.</p>
-  <p>This matters for memory because it means the system learns your preferences rather than requiring you to manually tune thresholds. You give feedback. The gate calibrates. The agent adapts.</p>
-  <p>Thompson Sampling also prevents over-blocking. If a pattern that was once dangerous stops being a problem — because the codebase changed, or you updated your workflow — thumbs-up feedback on future calls will widen the distribution back toward allowing. Memory is not one-way.</p>
-
-  <h2>Setup: persistent memory in two minutes</h2>
-  <p>ThumbGate ships as an MCP server. Any agent that speaks MCP — Claude Code, Cursor, Codex, Gemini, Amp, OpenCode — can connect to it. You initialize once and the memory layer is active for every subsequent session.</p>
-
-  <pre><code>npx thumbgate init</code></pre>
-
-  <p>That command sets up:</p>
-  <ul>
-    <li>The SQLite+FTS5 lesson database in <code>.claude/memory/</code></li>
-    <li>The feedback log at <code>.claude/memory/feedback/feedback-log.jsonl</code></li>
-    <li>Prevention rules at <code>.claude/memory/feedback/prevention-rules.md</code></li>
-    <li>A PreToolUse hook that reads gates on every tool call</li>
-    <li>The MCP server adapter for your agent runtime</li>
-  </ul>
-
-  <p>After init, your agent starts each session with context assembled from relevant past lessons. It does not start blank. It starts informed.</p>
-
-  <h3>What memory looks like on day one vs. day thirty</h3>
-  <p>On day one, the database is empty. The agent behaves the same as it always has. You give feedback on its actions.</p>
-  <p>By day thirty, the database has accumulated dozens of lessons. The agent's context at session start includes the most relevant ones. Prevention rules have tightened around patterns that caused problems. Patterns that worked have been reinforced. The agent makes fewer mistakes — not because it was retrained, but because the gates learned from your feedback.</p>
-  <p>That is persistent memory in practice: not a bigger context window, not a longer system prompt, but a feedback loop that accumulates signal and converts it into durable enforcement.</p>
-
-  <div class="cta-box">
-    <h2 style="color:var(--text);font-size:1.3rem;margin:0 0 8px;">Give your agent memory that survives restarts</h2>
-    <p>One command. Works with Claude Code, Cursor, Codex, Gemini, Amp, and any MCP-compatible agent.</p>
-    <div class="cta-install">$ npx thumbgate init</div>
-  </div>
-
-  <div class="related">
-    <h3>Related articles</h3>
-    <a href="/learn/agent-harness-pattern">The Agent Harness Pattern: Why Your AI Needs a Seatbelt &rarr;</a>
-    <a href="/learn/mcp-pre-action-gates-explained">MCP Pre-Action Gates Explained &rarr;</a>
-    <a href="/learn/stop-ai-agent-force-push">How to Stop AI Agents From Force-Pushing to Main &rarr;</a>
-    <a href="/learn/vibe-coding-safety-net">The Vibe Coding Safety Net You Are Missing &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>