thumbgate 0.9.13 → 1.0.0

package/scripts/seo-gsd.js

@@ -67,12 +67,30 @@ const HIGH_ROI_QUERY_SEEDS = [
     source: 'seed',
     notes: 'Problem-led copy that maps to landing-page positioning.',
   },
+  {
+    query: 'cursor prevent repeated mistakes',
+    businessValue: 87,
+    source: 'seed',
+    notes: 'High-intent Cursor workflow page for developers already feeling repeat-failure pain.',
+  },
   {
     query: 'claude code prevent repeated mistakes',
     businessValue: 86,
     source: 'seed',
     notes: 'High-intent pain query for Claude Code buyers.',
   },
+  {
+    query: 'codex cli guardrails',
+    businessValue: 84,
+    source: 'seed',
+    notes: 'Guardrail-focused page for Codex CLI buyers who want prevention, not just memory.',
+  },
+  {
+    query: 'gemini cli feedback memory',
+    businessValue: 82,
+    source: 'seed',
+    notes: 'Integration page for Gemini CLI users who need memory plus enforcement.',
+  },
 ];
 
 const PAGE_BLUEPRINTS = [
@@ -225,6 +243,55 @@ const PAGE_BLUEPRINTS = [
     ],
     relatedPaths: ['/compare/speclock', '/guides/claude-code-feedback'],
   },
+  {
+    query: 'stop ai coding agents from repeating mistakes',
+    path: '/guides/stop-repeated-ai-agent-mistakes',
+    pageType: 'guide',
+    pillar: 'pre-action-gates',
+    title: 'How to Stop AI Coding Agents From Repeating Mistakes | ThumbGate',
+    heroTitle: 'How to Stop AI Coding Agents From Repeating Mistakes',
+    heroSummary: 'If your agent keeps repeating the same bad move, the fix is not more memory alone. The fix is a feedback loop that turns repeated failures into pre-action gates before the next tool call executes.',
+    takeaways: [
+      'Repeated mistakes are a workflow problem, not just a context-window problem.',
+      'ThumbGate turns thumbs-down feedback into prevention rules and runtime gates.',
+      'This page is meant to move problem-aware buyers into the Pro path or a concrete install.',
+    ],
+    sections: [
+      {
+        heading: 'Why repeated mistakes keep happening',
+        paragraphs: [
+          'AI coding agents are fast, but they forget operational pain surprisingly easily. One bad deployment, force-push, or skipped verification step often turns into another because the system remembered the transcript but never enforced the lesson.',
+          'That is why teams feel stuck in a correction loop. They keep teaching the same rule, but the next session still allows the same risky action.',
+        ],
+      },
+      {
+        heading: 'What changes when feedback becomes enforcement',
+        bullets: [
+          'Thumbs down captures the exact failure you do not want repeated.',
+          'Repeated failures promote into linked prevention rules.',
+          'Pre-action gates intercept the risky tool call before execution.',
+          'Thumbs up reinforces the safe path so the agent learns what good looks like too.',
+        ],
+      },
+      {
+        heading: 'What a buyer should do next',
+        paragraphs: [
+          'If the pain is already real, do not start with a long architecture project. Start by wiring ThumbGate into the workflow where the agent has already burned time or trust, then watch the next repeat attempt get blocked before damage lands.',
+        ],
+      },
+    ],
+    faq: [
+      {
+        question: 'Is memory alone enough to stop repeated mistakes?',
+        answer: 'Usually no. Memory helps retrieval, but ThumbGate adds pre-action gates so the same risky move can be blocked before the next command executes.',
+      },
+      {
+        question: 'Does ThumbGate only punish bad behavior?',
+        answer: 'No. Thumbs up reinforces good behavior, so the loop captures safe patterns as well as failures.',
+      },
+    ],
+    relatedPaths: ['/guides/pre-action-gates', '/guides/claude-code-feedback'],
+  },
   {
     query: 'claude code feedback memory',
     path: '/guides/claude-code-feedback',
@@ -273,6 +340,150 @@ const PAGE_BLUEPRINTS = [
     ],
     relatedPaths: ['/guides/pre-action-gates', '/compare/mem0'],
   },
+  {
+    query: 'cursor prevent repeated mistakes',
+    path: '/guides/cursor-agent-guardrails',
+    pageType: 'integration',
+    pillar: 'agent-workflows',
+    title: 'Cursor Agent Guardrails | Stop Repeated Mistakes with ThumbGate',
+    heroTitle: 'Cursor Guardrails That Block Repeated Mistakes',
+    heroSummary: 'Cursor moves fast, which makes repeated mistakes expensive. ThumbGate gives Cursor users a feedback loop that turns thumbs-down corrections into pre-action gates before the next risky step fires.',
+    takeaways: [
+      'Cursor users want speed without trusting the agent blindly.',
+      'ThumbGate adds enforcement without forcing a platform switch.',
+      'The page should answer the buyer question in one line: how do I stop Cursor from doing the same bad thing again?',
+    ],
+    sections: [
+      {
+        heading: 'The Cursor workflow problem',
+        paragraphs: [
+          'Cursor can move from idea to edits quickly, but the failure mode is familiar: the same wrong refactor, risky shell command, or skipped check comes back in the next session because nothing hardened the workflow.',
+        ],
+      },
+      {
+        heading: 'How ThumbGate fits into Cursor',
+        bullets: [
+          'Capture thumbs-up/down feedback on agent behavior.',
+          'Promote repeated failures into prevention rules.',
+          'Block known-bad commands with pre-action gates before execution.',
+          'Keep the memory and gates local-first so the operator retains control.',
+        ],
+      },
+      {
+        heading: 'What makes this different from a rule file',
+        paragraphs: [
+          'Static rules help on day one. ThumbGate helps on day two and day twenty because it keeps learning from live corrections instead of relying on a fixed checklist that drifts out of date.',
+        ],
+      },
+    ],
+    faq: [
+      {
+        question: 'Do I need to leave Cursor to use ThumbGate?',
+        answer: 'No. ThumbGate is designed to sit alongside existing coding-agent workflows so you can add enforcement without switching tools.',
+      },
+      {
+        question: 'What kind of mistakes can Cursor guardrails stop?',
+        answer: 'Repeated failures like risky git actions, destructive scripts, skipped verification, or any other known-bad pattern you have already corrected once.',
+      },
+    ],
+    relatedPaths: ['/guides/stop-repeated-ai-agent-mistakes', '/guides/pre-action-gates'],
+  },
+  {
+    query: 'codex cli guardrails',
+    path: '/guides/codex-cli-guardrails',
+    pageType: 'integration',
+    pillar: 'agent-workflows',
+    title: 'Codex CLI Guardrails | Prevent Repeated Mistakes with ThumbGate',
+    heroTitle: 'Codex CLI Guardrails That Actually Enforce',
+    heroSummary: 'Codex CLI can move quickly through repo tasks, but buyers need more than good intentions. ThumbGate adds a reliability gateway so repeated mistakes become searchable lessons, linked rules, and pre-action enforcement.',
+    takeaways: [
+      'Codex CLI buyers are usually looking for safe autonomy, not just more prompts.',
+      'ThumbGate sits in the critical gap between feedback and execution.',
+      'This page should rank for people who want guardrails without giving up CLI speed.',
+    ],
+    sections: [
+      {
+        heading: 'What Codex CLI users usually need',
+        paragraphs: [
+          'The problem is rarely a single bad command. It is the cost of the same failure pattern showing up across branches, sessions, or rushed workflows. Once that pattern is obvious, the buyer wants a durable control point.',
+        ],
+      },
+      {
+        heading: 'What ThumbGate adds',
+        bullets: [
+          'Feedback capture with explicit thumbs-up/down signals.',
+          'Searchable lessons and linked prevention rules.',
+          'Pre-action gates that block repeated bad commands before they run.',
+          'Verification evidence that gives teams something concrete to audit.',
+        ],
+      },
+      {
+        heading: 'Why this matters for revenue',
+        paragraphs: [
+          'Guardrails are easier to buy when the outcome is obvious: less rework, fewer repeated failures, and a visible chain from operator feedback to enforced behavior.',
+        ],
+      },
+    ],
+    faq: [
+      {
+        question: 'Is ThumbGate only for Codex CLI?',
+        answer: 'No. Codex CLI is one supported workflow, but the same feedback and enforcement loop also works across Claude Code, Cursor, Gemini, Amp, and OpenCode.',
+      },
+      {
+        question: 'How are Codex CLI guardrails different from prompt instructions?',
+        answer: 'Prompt instructions are advisory. ThumbGate pre-action gates intercept the tool call itself and block the known-bad pattern before execution.',
+      },
+    ],
+    relatedPaths: ['/guides/pre-action-gates', '/compare/mem0'],
+  },
+  {
+    query: 'gemini cli feedback memory',
+    path: '/guides/gemini-cli-feedback-memory',
+    pageType: 'integration',
+    pillar: 'agent-workflows',
+    title: 'Gemini CLI Feedback Memory | Memory Plus Enforcement with ThumbGate',
+    heroTitle: 'Gemini CLI Feedback Memory That Leads to Enforcement',
+    heroSummary: 'Gemini CLI users often start by asking for better memory. ThumbGate answers the bigger need: memory that can become prevention rules and pre-action gates when the same mistake shows up twice.',
+    takeaways: [
+      'Gemini CLI searchers often begin with memory but buy because of enforcement.',
+      'ThumbGate keeps the local-first memory story while adding runtime blocking.',
+      'The ideal conversion path here is memory query to product proof to Pro page.',
+    ],
+    sections: [
+      {
+        heading: 'Why memory is only step one',
+        paragraphs: [
+          'Persistent memory helps Gemini CLI recall past context, but it still leaves a blind spot. Remembering that a workflow went badly is different from preventing the next risky action when the same pattern appears again.',
+        ],
+      },
+      {
+        heading: 'What ThumbGate adds on top',
+        bullets: [
+          'Local-first lessons you can search across sessions.',
+          'Structured thumbs-up/down feedback for reinforcement and correction.',
+          'Prevention rules linked to past failures.',
+          'Pre-action gates that stop repeated mistakes before execution.',
+        ],
+      },
+      {
+        heading: 'Who this is really for',
+        paragraphs: [
+          'This page is for operators who already know memory matters, but now need a reliability layer that protects live workflows instead of just preserving notes about them.',
+        ],
+      },
+    ],
+    faq: [
+      {
+        question: 'Does ThumbGate replace Gemini CLI memory?',
+        answer: 'No. ThumbGate extends the memory story with searchable lessons, rules, and gates so memory becomes operationally useful instead of purely historical.',
+      },
+      {
+        question: 'Can this stay local-first?',
+        answer: 'Yes. ThumbGate is built for local-first workflows, which lowers risk for developers who do not want sensitive history pushed into a hosted memory layer.',
+      },
+    ],
+    relatedPaths: ['/compare/mem0', '/guides/stop-repeated-ai-agent-mistakes'],
+  },
   {
     query: 'claude desktop extension plugin thumbgate',
     path: '/guides/claude-desktop',
@@ -444,7 +655,7 @@ function classifyIntent(query) {
     return 'commercial';
   }
   if (/\b(what is|how to|guide|best practices|why)\b/.test(normalized)) return 'informational';
-  if (/\b(guardrails|pre-action gates|feedback|prevent repeated mistakes|memory)\b/.test(normalized)) {
+  if (/\b(guardrails|pre-action gates|feedback|prevent repeated mistakes|repeating mistakes|memory)\b/.test(normalized)) {
     return 'commercial';
   }
   return 'informational';
@@ -454,7 +665,7 @@ function inferPillar(query) {
   const normalized = normalizeText(query).toLowerCase();
   if (/\b(speclock|mem0|alternative|vs|compare|comparison)\b/.test(normalized)) return 'comparison';
   if (/\b(thumbs up|thumbs down|feedback|reinforce|mistake)\b/.test(normalized)) return 'feedback-loop';
-  if (/\b(pre-action gates|guardrails|block|prevent repeated mistakes)\b/.test(normalized)) return 'pre-action-gates';
+  if (/\b(pre-action gates|guardrails|block|prevent repeated mistakes|repeating mistakes)\b/.test(normalized)) return 'pre-action-gates';
   if (/\b(claude code|cursor|codex|gemini|amp|opencode|integration|plugin)\b/.test(normalized)) return 'agent-workflows';
   return 'ai-agent-reliability';
 }
@@ -463,6 +674,8 @@ function inferPersona(query) {
   const normalized = normalizeText(query).toLowerCase();
   if (normalized.includes('claude code')) return 'claude-code-builder';
   if (normalized.includes('cursor')) return 'cursor-builder';
+  if (normalized.includes('codex')) return 'codex-builder';
+  if (normalized.includes('gemini')) return 'gemini-builder';
   if (/\b(vs|alternative|compare)\b/.test(normalized)) return 'tool-evaluator';
   if (/\b(guardrails|pre-action gates)\b/.test(normalized)) return 'engineering-lead';
   return 'ai-engineer';
@@ -628,8 +841,8 @@ function createPageSpec(blueprint, row) {
     faq: blueprint.faq,
     relatedPages,
     cta: {
-      label: 'Review verification evidence',
-      href: PRODUCT.verificationUrl,
+      label: 'See ThumbGate Pro',
+      href: `/pro?utm_source=website&utm_medium=seo_page&utm_campaign=${blueprint.path.split('/').filter(Boolean).join('_')}`,
     },
     proofLinks: [
       { label: 'Verification evidence', href: PRODUCT.verificationUrl },

package/scripts/social-analytics/load-env.js

@@ -2,7 +2,12 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
-const dotenv = require('dotenv');
+let dotenv = null;
+try {
+  dotenv = require('dotenv');
+} catch (_) {
+  dotenv = null;
+}
 
 const DEFAULT_ENV_PATH = path.resolve(__dirname, '..', '..', '.env');
 
@@ -20,7 +25,8 @@ function loadLocalEnv(options = {}) {
     };
   }
 
-  const parsed = dotenv.parse(fs.readFileSync(resolvedPath, 'utf8'));
+  const source = fs.readFileSync(resolvedPath, 'utf8');
+  const parsed = dotenv ? dotenv.parse(source) : parseEnvFallback(source);
   const loadedKeys = [];
   const override = options.override === true;
 
@@ -39,8 +45,33 @@ function loadLocalEnv(options = {}) {
   };
 }
 
+function parseEnvFallback(source) {
+  const parsed = {};
+  for (const rawLine of String(source).split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith('#')) {
+      continue;
+    }
+    const separatorIndex = line.indexOf('=');
+    if (separatorIndex <= 0) {
+      continue;
+    }
+    const key = line.slice(0, separatorIndex).trim();
+    let value = line.slice(separatorIndex + 1).trim();
+    if (
+      (value.startsWith('"') && value.endsWith('"')) ||
+      (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      value = value.slice(1, -1);
+    }
+    parsed[key] = value;
+  }
+  return parsed;
+}
+
 module.exports = {
   DEFAULT_ENV_PATH,
   loadLocalEnv,
+  parseEnvFallback,
   resolveEnvPath,
 };

package/scripts/social-analytics/store.js

@@ -2,11 +2,209 @@
 
 const path = require('path');
 const fs = require('fs');
-const Database = require('better-sqlite3');
+let Database = null;
+try {
+  Database = require('better-sqlite3');
+} catch (_) {
+  Database = null;
+}
 
 const DEFAULT_DB_PATH = path.join(__dirname, 'db', 'social-analytics.db');
 const SCHEMA_PATH = path.join(__dirname, 'db', 'schema.sql');
 
+class MemoryStatement {
+  constructor(handler) {
+    this.handler = handler;
+  }
+
+  run(params) {
+    return this.handler.run(params);
+  }
+
+  all(params) {
+    return this.handler.all(params);
+  }
+}
+
+class MemoryDatabase {
+  constructor() {
+    this.tables = {
+      engagement_metrics: [],
+      follower_snapshots: [],
+    };
+  }
+
+  pragma() {}
+
+  exec() {}
+
+  close() {}
+
+  prepare(sql) {
+    const normalized = sql.replace(/\s+/g, ' ').trim();
+
+    if (normalized.includes('INSERT OR REPLACE INTO engagement_metrics')) {
+      return new MemoryStatement({
+        run: (params) => {
+          const index = this.tables.engagement_metrics.findIndex(
+            (row) =>
+              row.platform === params.platform &&
+              row.post_id === params.post_id &&
+              row.metric_date === params.metric_date
+          );
+          const row = { ...params };
+          if (index >= 0) {
+            this.tables.engagement_metrics[index] = row;
+          } else {
+            this.tables.engagement_metrics.push(row);
+          }
+          return { changes: 1 };
+        },
+      });
+    }
+
+    if (normalized.includes('INSERT OR REPLACE INTO follower_snapshots')) {
+      return new MemoryStatement({
+        run: (params) => {
+          const index = this.tables.follower_snapshots.findIndex(
+            (row) => row.platform === params.platform && row.snapshot_date === params.snapshot_date
+          );
+          const row = { ...params };
+          if (index >= 0) {
+            this.tables.follower_snapshots[index] = row;
+          } else {
+            this.tables.follower_snapshots.push(row);
+          }
+          return { changes: 1 };
+        },
+      });
+    }
+
+    if (normalized.includes('SELECT * FROM engagement_metrics WHERE platform = ?')) {
+      return new MemoryStatement({
+        all: (platform) =>
+          this.tables.engagement_metrics.filter((row) => row.platform === platform),
+      });
+    }
+
+    const literalPlatformMatch = normalized.match(
+      /^SELECT \* FROM engagement_metrics WHERE platform = '([^']+)'$/i
+    );
+    if (literalPlatformMatch) {
+      const [, platform] = literalPlatformMatch;
+      return new MemoryStatement({
+        all: () =>
+          this.tables.engagement_metrics.filter((row) => row.platform === platform),
+      });
+    }
+
+    if (normalized.includes('FROM engagement_metrics') && normalized.includes('GROUP BY platform')) {
+      return new MemoryStatement({
+        all: (params = {}) => {
+          const rows = this.tables.engagement_metrics.filter((row) => {
+            if (row.metric_date < params.cutoff) return false;
+            if (params.platform && row.platform !== params.platform) return false;
+            return true;
+          });
+          const grouped = new Map();
+          for (const row of rows) {
+            const bucket = grouped.get(row.platform) || {
+              platform: row.platform,
+              post_count: 0,
+              total_impressions: 0,
+              total_reach: 0,
+              total_likes: 0,
+              total_comments: 0,
+              total_shares: 0,
+              total_saves: 0,
+              total_clicks: 0,
+              total_video_views: 0,
+              _postIds: new Set(),
+              _rows: 0,
+            };
+            bucket._postIds.add(row.post_id);
+            bucket.total_impressions += row.impressions || 0;
+            bucket.total_reach += row.reach || 0;
+            bucket.total_likes += row.likes || 0;
+            bucket.total_comments += row.comments || 0;
+            bucket.total_shares += row.shares || 0;
+            bucket.total_saves += row.saves || 0;
+            bucket.total_clicks += row.clicks || 0;
+            bucket.total_video_views += row.video_views || 0;
+            bucket._rows += 1;
+            grouped.set(row.platform, bucket);
+          }
+          return [...grouped.values()]
+            .map((bucket) => ({
+              platform: bucket.platform,
+              post_count: bucket._postIds.size,
+              total_impressions: bucket.total_impressions,
+              total_reach: bucket.total_reach,
+              total_likes: bucket.total_likes,
+              total_comments: bucket.total_comments,
+              total_shares: bucket.total_shares,
+              total_saves: bucket.total_saves,
+              total_clicks: bucket.total_clicks,
+              total_video_views: bucket.total_video_views,
+              avg_impressions: Number((bucket.total_impressions / bucket._rows).toFixed(2)),
+              avg_likes: Number((bucket.total_likes / bucket._rows).toFixed(2)),
+            }))
+            .sort((a, b) => b.total_impressions - a.total_impressions);
+        },
+      });
+    }
+
+    if (normalized.includes('FROM engagement_metrics') && normalized.includes('GROUP BY platform, post_id')) {
+      return new MemoryStatement({
+        all: ({ cutoff, limit }) => {
+          const rows = this.tables.engagement_metrics.filter((row) => row.metric_date >= cutoff);
+          const grouped = new Map();
+          for (const row of rows) {
+            const key = `${row.platform}::${row.post_id}`;
+            const bucket = grouped.get(key) || {
+              platform: row.platform,
+              content_type: row.content_type,
+              post_id: row.post_id,
+              post_url: row.post_url ?? null,
+              published_at: row.published_at ?? null,
+              total_engagement: 0,
+              total_impressions: 0,
+              total_likes: 0,
+              total_comments: 0,
+              total_shares: 0,
+              total_saves: 0,
+              total_video_views: 0,
+            };
+            bucket.total_engagement +=
+              (row.likes || 0) + (row.comments || 0) + (row.shares || 0) + (row.saves || 0);
+            bucket.total_impressions += row.impressions || 0;
+            bucket.total_likes += row.likes || 0;
+            bucket.total_comments += row.comments || 0;
+            bucket.total_shares += row.shares || 0;
+            bucket.total_saves += row.saves || 0;
+            bucket.total_video_views += row.video_views || 0;
+            grouped.set(key, bucket);
+          }
+          return [...grouped.values()]
+            .sort((a, b) => b.total_engagement - a.total_engagement)
+            .slice(0, limit);
+        },
+      });
+    }
+
+    if (normalized.includes('FROM follower_snapshots')) {
+      return new MemoryStatement({
+        all: ({ platform, cutoff }) =>
+          this.tables.follower_snapshots
+            .filter((row) => row.platform === platform && row.snapshot_date >= cutoff)
+            .sort((a, b) => a.snapshot_date.localeCompare(b.snapshot_date)),
+      });
+    }
+
+    throw new Error(`MemoryDatabase does not support query: ${normalized}`);
+  }
+}
+
 /**
  * Opens the SQLite database, applies the schema, and returns the db instance.
  * Idempotent — safe to call multiple times; schema uses IF NOT EXISTS guards.
@@ -23,7 +221,7 @@ function initDb(dbPath = DEFAULT_DB_PATH) {
     fs.mkdirSync(dir, { recursive: true });
   }
 
-  const db = new Database(resolvedPath);
+  const db = Database ? new Database(resolvedPath) : new MemoryDatabase();
   db.pragma('busy_timeout = 3000');
 
   // Enable WAL mode for better concurrent read performance.

package/scripts/statusline-cache-path.js

@@ -2,21 +2,24 @@
 'use strict';
 
 const path = require('path');
-const { resolveFeedbackDir } = require('./feedback-paths');
+const {
+  listFeedbackArtifactPaths,
+  resolveFeedbackDir,
+  resolveProjectDir,
+} = require('./feedback-paths');
 
 function unique(values = []) {
   return [...new Set(values.filter(Boolean).map((value) => path.resolve(value)))];
 }
 
 function getStatuslineCacheCandidates(options = {}) {
-  const cwd = options.cwd || process.cwd();
-  const home = options.home || process.env.HOME || process.env.USERPROFILE || '';
-  const feedbackDir = resolveFeedbackDir({ cwd, env: options.env || process.env });
+  const env = options.env || process.env;
+  const projectDir = resolveProjectDir({ cwd: options.cwd, env });
+  const feedbackDir = resolveFeedbackDir({ projectDir, env });
 
   return unique([
+    ...listFeedbackArtifactPaths('statusline_cache.json', { projectDir, env }),
     path.join(feedbackDir, 'statusline_cache.json'),
-    path.join(cwd, '.thumbgate', 'statusline_cache.json'),
-    home ? path.join(home, '.thumbgate', 'statusline_cache.json') : null,
   ]);
 }
 

package/scripts/sync-version.js

@@ -18,6 +18,7 @@ const fs = require('fs');
 const path = require('path');
 
 const PROJECT_ROOT = path.join(__dirname, '..');
+const VERSION_PATTERN = '\\d+\\.\\d+\\.\\d+(?:-[0-9A-Za-z.-]+)?';
 
 function explicitPinnedServeArgs(version) {
   return ['--yes', '--package', `thumbgate@${version}`, 'thumbgate', 'serve'];
@@ -308,7 +309,7 @@ function syncVersion(opts) {
     'plugins/codex-profile/INSTALL.md',
     'plugins/opencode-profile/INSTALL.md',
   ];
-  const pinnedPackagePattern = /thumbgate@\d+\.\d+\.\d+/g;
+  const pinnedPackagePattern = new RegExp(`thumbgate@${VERSION_PATTERN}`, 'g');
   for (const relPath of pinnedPackageTargets) {
     const filePath = path.join(PROJECT_ROOT, relPath);
     if (!fs.existsSync(filePath)) continue;
@@ -329,7 +330,7 @@ function syncVersion(opts) {
   if (fs.existsSync(path.join(PROJECT_ROOT, landingPath))) {
     const landingContent = fs.readFileSync(path.join(PROJECT_ROOT, landingPath), 'utf-8');
     // Match any version pattern in the hero badge
-    const badgeMatch = landingContent.match(/v(\d+\.\d+\.\d+) — Hosted API/);
+    const badgeMatch = landingContent.match(new RegExp(`v(${VERSION_PATTERN}) — Hosted API`));
     if (badgeMatch && badgeMatch[1] !== version) {
       drifted.push({ file: landingPath, field: 'hero-badge', current: badgeMatch[1] });
       if (!checkOnly) {
@@ -337,7 +338,7 @@ function syncVersion(opts) {
       }
     }
     // JSON snippet version
-    const jsonMatch = landingContent.match(/"version"<\/span><span class="out">: <\/span><span class="val">"(\d+\.\d+\.\d+)"/);
+    const jsonMatch = landingContent.match(new RegExp(`"version"<\\/span><span class="out">: <\\/span><span class="val">"(${VERSION_PATTERN})"`));
     if (jsonMatch && jsonMatch[1] !== version) {
       drifted.push({ file: landingPath, field: 'json-snippet', current: jsonMatch[1] });
       if (!checkOnly) {
@@ -351,7 +352,7 @@ function syncVersion(opts) {
   const mcpSubmPath = 'docs/mcp-hub-submission.md';
   if (fs.existsSync(path.join(PROJECT_ROOT, mcpSubmPath))) {
     const mcpContent = fs.readFileSync(path.join(PROJECT_ROOT, mcpSubmPath), 'utf-8');
-    const versionMatch = mcpContent.match(/## Version\s+(\d+\.\d+\.\d+)/);
+    const versionMatch = mcpContent.match(new RegExp(`## Version\\s+(${VERSION_PATTERN})`));
     if (versionMatch && versionMatch[1] !== version) {
       drifted.push({ file: mcpSubmPath, field: 'version-heading', current: versionMatch[1] });
       if (!checkOnly) {
@@ -366,18 +367,18 @@ function syncVersion(opts) {
   if (fs.existsSync(path.join(PROJECT_ROOT, publicIndexPath))) {
     const publicIndexFile = path.join(PROJECT_ROOT, publicIndexPath);
     const publicContent = fs.readFileSync(publicIndexFile, 'utf-8');
-    const heroVersionMatch = publicContent.match(/New in v(\d+\.\d+\.\d+):?/);
+    const heroVersionMatch = publicContent.match(new RegExp(`New in v(${VERSION_PATTERN}):?`));
     if (heroVersionMatch && heroVersionMatch[1] !== version) {
       drifted.push({ file: publicIndexPath, field: 'hero-release-note', current: heroVersionMatch[1] });
       if (!checkOnly) {
         fs.writeFileSync(
           publicIndexFile,
-          publicContent.replace(/New in v\d+\.\d+\.\d+:?/, `New in v${version}`)
+          publicContent.replace(new RegExp(`New in v${VERSION_PATTERN}:?`), `New in v${version}`)
         );
       }
     }
 
-    const proofMatch = publicContent.match(/Versioned proof: v(\d+\.\d+\.\d+)/);
+    const proofMatch = publicContent.match(new RegExp(`Versioned proof: v(${VERSION_PATTERN})`));
     if (proofMatch && proofMatch[1] !== version) {
       drifted.push({ file: publicIndexPath, field: 'proof-pill', current: proofMatch[1] });
       if (!checkOnly) {
@@ -385,11 +386,17 @@ function syncVersion(opts) {
       }
     }
 
-    const footerMatch = publicContent.match(/Context Gateway • v(\d+\.\d+\.\d+)/);
+    const footerMatch = publicContent.match(new RegExp(`(?:Context Gateway|MIT License) [•·] v(${VERSION_PATTERN})`));
     if (footerMatch && footerMatch[1] !== version) {
       drifted.push({ file: publicIndexPath, field: 'footer-version', current: footerMatch[1] });
       if (!checkOnly) {
-        replaceInFile(publicIndexPath, `Context Gateway • v${footerMatch[1]}`, `Context Gateway • v${version}`);
+        fs.writeFileSync(
+          publicIndexFile,
+          publicContent.replace(
+            new RegExp(`((?:Context Gateway|MIT License) [•·] )v${VERSION_PATTERN}`),
+            `$1v${version}`
+          )
+        );
       }
     }
     targets.push(publicIndexPath);
@@ -400,13 +407,13 @@ function syncVersion(opts) {
   const serverStdioFile = path.join(PROJECT_ROOT, serverStdioPath);
   if (fs.existsSync(serverStdioFile)) {
     const serverStdioContent = fs.readFileSync(serverStdioFile, 'utf-8');
-    const serverInfoMatch = serverStdioContent.match(/version:\s*'(\d+\.\d+\.\d+)'/);
+    const serverInfoMatch = serverStdioContent.match(new RegExp(`version:\\s*'(${VERSION_PATTERN})'`));
     if (serverInfoMatch && serverInfoMatch[1] !== version) {
       drifted.push({ file: serverStdioPath, field: 'server-info-version', current: serverInfoMatch[1] });
       if (!checkOnly) {
         fs.writeFileSync(
           serverStdioFile,
-          serverStdioContent.replace(/version:\s*'\d+\.\d+\.\d+'/, `version: '${version}'`)
+          serverStdioContent.replace(new RegExp(`version:\\s*'${VERSION_PATTERN}'`), `version: '${version}'`)
         );
       }
     }