thumbgate 1.16.12 → 1.16.19

package/scripts/ai-engineering-stack-guardrails.js

@@ -0,0 +1,256 @@
+#!/usr/bin/env node
+'use strict';
+
+const { listGateTemplates } = require('./gate-templates');
+
+const AI_STACK_CATEGORY = 'AI Engineering Stack Safety';
+const AI_STACK_TEMPLATE_IDS = new Set([
+  'require-ai-gateway-control-plane',
+  'require-progressive-mcp-tool-discovery',
+  'require-agent-context-freshness',
+  'require-risk-tiered-ai-review',
+  'require-sandboxed-background-agent-runtime',
+]);
+
+function splitCsv(value) {
+  if (Array.isArray(value)) return value.map(String).map((item) => item.trim()).filter(Boolean);
+  if (value === undefined || value === null || value === true) return [];
+  return String(value)
+    .split(',')
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+function normalizeBoolean(value) {
+  if (value === true) return true;
+  if (value === false || value === undefined || value === null) return false;
+  return /^(1|true|yes|on)$/i.test(String(value).trim());
+}
+
+function toNumber(value) {
+  if (value === undefined || value === null || value === '') return null;
+  const number = Number(value);
+  return Number.isFinite(number) ? number : null;
+}
+
+function normalizeOptions(options = {}) {
+  const mcpToolCount = toNumber(options['mcp-tool-count'] || options.tools || options['tool-count']);
+  const gateway = normalizeBoolean(options.gateway || options['ai-gateway'] || options.proxy || options['proxy-worker']);
+  const directProviderKeys = normalizeBoolean(options['direct-provider-keys'] || options['keys-on-laptops']);
+  const codeMode = normalizeBoolean(options['code-mode'] || options['progressive-discovery']);
+  const agentsMd = normalizeBoolean(options['agents-md'] || options['agent-context']);
+  const llmWikiPages = toNumber(options['llm-wiki-pages'] || options['wiki-pages']);
+  const contextFreshnessDays = toNumber(options['context-freshness-days'] || options['stale-days']);
+  const aiReviewer = normalizeBoolean(options['ai-reviewer'] || options.reviewer);
+  const codexRules = normalizeBoolean(options['codex-rules'] || options['standards-as-skills'] || options.skills);
+  const backgroundAgents = normalizeBoolean(options['background-agents'] || options['durable-agents']);
+  const sandbox = normalizeBoolean(options.sandbox || options['sandbox-sdk'] || options['isolated-runtime']);
+  const workflows = splitCsv(options.workflows || options.workflow);
+  const highRiskWorkflows = splitCsv(options['high-risk-workflows'] || options['risky-workflows']);
+
+  return {
+    stackName: String(options.stack || options['stack-name'] || 'internal-ai-engineering-stack').trim() || 'internal-ai-engineering-stack',
+    gateway,
+    directProviderKeys,
+    mcpToolCount,
+    codeMode,
+    agentsMd,
+    llmWikiPages,
+    contextFreshnessDays,
+    aiReviewer,
+    codexRules,
+    backgroundAgents,
+    sandbox,
+    workflows,
+    highRiskWorkflows,
+  };
+}
+
+function templateApplicability(template, options) {
+  if (template.id === 'require-ai-gateway-control-plane') {
+    return options.directProviderKeys || !options.gateway;
+  }
+  if (template.id === 'require-progressive-mcp-tool-discovery') {
+    return (options.mcpToolCount !== null && options.mcpToolCount >= 20) || !options.codeMode;
+  }
+  if (template.id === 'require-agent-context-freshness') {
+    return !options.agentsMd ||
+      (options.llmWikiPages !== null && options.llmWikiPages > 0) ||
+      (options.contextFreshnessDays !== null && options.contextFreshnessDays > 14);
+  }
+  if (template.id === 'require-risk-tiered-ai-review') {
+    return !options.aiReviewer || !options.codexRules || options.highRiskWorkflows.length > 0;
+  }
+  if (template.id === 'require-sandboxed-background-agent-runtime') {
+    return options.backgroundAgents && !options.sandbox;
+  }
+  return false;
+}
+
+function buildSignals(options) {
+  return [
+    gatewaySignal(options),
+    mcpContextSignal(options),
+    contextFreshnessSignal(options),
+    reviewEnforcementSignal(options),
+    backgroundRuntimeSignal(options),
+  ].filter(Boolean);
+}
+
+function gatewaySignal(options) {
+  if (options.gateway && !options.directProviderKeys) return null;
+  return {
+    id: 'gateway_control_plane',
+    label: 'Model gateway control plane',
+    values: [
+      options.gateway ? 'gateway present' : 'gateway missing',
+      options.directProviderKeys ? 'direct provider keys detected' : null,
+    ].filter(Boolean),
+    risk: 'AI usage, keys, cost attribution, and data-retention controls fragment across clients',
+  };
+}
+
+function mcpContextSignal(options) {
+  if (!((options.mcpToolCount !== null && options.mcpToolCount >= 20) || !options.codeMode)) return null;
+  return {
+    id: 'mcp_context_bloat',
+    label: 'MCP tool schema overhead',
+    values: [
+      options.mcpToolCount !== null ? `${options.mcpToolCount} MCP tools` : null,
+      options.codeMode ? 'progressive discovery enabled' : 'code mode missing',
+    ].filter(Boolean),
+    risk: 'large tool schemas consume prompt budget before the agent starts work',
+  };
+}
+
+function contextFreshnessSignal(options) {
+  if (options.agentsMd && options.llmWikiPages === null && options.contextFreshnessDays === null) return null;
+  return {
+    id: 'agent_context_freshness',
+    label: 'AGENTS.md and LLM wiki freshness',
+    values: [
+      options.agentsMd ? 'AGENTS.md present' : 'AGENTS.md missing',
+      options.llmWikiPages !== null ? `${options.llmWikiPages} LLM wiki pages` : null,
+      options.contextFreshnessDays !== null ? `${options.contextFreshnessDays} days since refresh` : null,
+    ].filter(Boolean),
+    risk: 'agents act on stale repo conventions, ownership, tests, or system dependencies',
+  };
+}
+
+function reviewEnforcementSignal(options) {
+  if (options.aiReviewer && options.codexRules && options.highRiskWorkflows.length === 0) return null;
+  return {
+    id: 'review_enforcement_gap',
+    label: 'Risk-tiered AI review and standards',
+    values: [
+      options.aiReviewer ? 'AI reviewer present' : 'AI reviewer missing',
+      options.codexRules ? 'standards-as-skills present' : 'codex rules missing',
+      ...options.highRiskWorkflows,
+    ].filter(Boolean),
+    risk: 'agent changes ship without repeatable severity, category, and rule-id feedback',
+  };
+}
+
+function backgroundRuntimeSignal(options) {
+  if (!options.backgroundAgents && options.sandbox) return null;
+  return {
+    id: 'background_agent_runtime',
+    label: 'Background agent runtime isolation',
+    values: [
+      options.backgroundAgents ? 'background agents enabled' : 'background agents not declared',
+      options.sandbox ? 'sandbox present' : 'sandbox missing',
+    ].filter(Boolean),
+    risk: 'long-running agents can clone, build, test, or publish without durable audit and isolation',
+  };
+}
+
+function buildAiEngineeringStackGuardrailsPlan(rawOptions = {}, templatesPath) {
+  const options = normalizeOptions(rawOptions);
+  const templates = listGateTemplates(templatesPath)
+    .filter((template) => template.category === AI_STACK_CATEGORY && AI_STACK_TEMPLATE_IDS.has(template.id))
+    .map((template) => ({
+      ...template,
+      recommended: templateApplicability(template, options),
+    }));
+  const signals = buildSignals(options);
+  const recommendedTemplates = templates.filter((template) => template.recommended);
+
+  return {
+    name: 'thumbgate-ai-engineering-stack-guardrails',
+    status: recommendedTemplates.length > 0 ? 'actionable' : 'ready',
+    stackName: options.stackName,
+    posture: {
+      gateway: options.gateway,
+      directProviderKeys: options.directProviderKeys,
+      mcpToolCount: options.mcpToolCount,
+      codeMode: options.codeMode,
+      agentsMd: options.agentsMd,
+      llmWikiPages: options.llmWikiPages,
+      contextFreshnessDays: options.contextFreshnessDays,
+      aiReviewer: options.aiReviewer,
+      codexRules: options.codexRules,
+      backgroundAgents: options.backgroundAgents,
+      sandbox: options.sandbox,
+      workflows: options.workflows,
+      highRiskWorkflows: options.highRiskWorkflows,
+    },
+    summary: {
+      signalCount: signals.length,
+      templateCount: templates.length,
+      recommendedTemplateCount: recommendedTemplates.length,
+    },
+    signals,
+    templates,
+    nextActions: [
+      'Put every model request behind one gateway/proxy so keys, cost, provider routing, and retention policy are centralized.',
+      'Collapse large MCP surfaces behind progressive discovery or code-mode search/execute tools before schema bloat burns context.',
+      'Generate short AGENTS.md and LLM wiki pages from source metadata, then gate stale context when repo structure changes.',
+      'Require risk-tiered AI review that cites standards-as-skills before high-risk agent changes merge.',
+      'Run background agents in isolated, durable environments with build/test logs and resumable session state.',
+    ],
+    exampleCommand: 'npx thumbgate ai-engineering-stack-guardrails --mcp-tool-count=182 --direct-provider-keys --llm-wiki-pages=24 --context-freshness-days=30 --background-agents --high-risk-workflows=deploy,billing --json',
+  };
+}
+
+function formatAiEngineeringStackGuardrailsPlan(report) {
+  const lines = [
+    '',
+    'ThumbGate AI Engineering Stack Guardrails',
+    '-'.repeat(43),
+    `Status   : ${report.status}`,
+    `Stack    : ${report.stackName}`,
+    `Signals  : ${report.summary.signalCount}`,
+    `Templates: ${report.summary.recommendedTemplateCount}/${report.summary.templateCount} recommended`,
+  ];
+
+  if (report.signals.length > 0) {
+    lines.push('', 'Detected stack risk signals:');
+    for (const signal of report.signals) {
+      lines.push(`  - ${signal.label}: ${signal.values.join(', ') || 'needs evidence'}`);
+      lines.push(`    Risk: ${signal.risk}`);
+    }
+  }
+
+  lines.push('', 'Recommended templates:');
+  const recommended = report.templates.filter((template) => template.recommended);
+  if (recommended.length === 0) {
+    lines.push('  - No AI-stack gaps were passed. Keep monitoring gateway, MCP, context, review, and sandbox evidence.');
+  } else {
+    for (const template of recommended) {
+      lines.push(`  - ${template.id} [${template.defaultAction}]`);
+      lines.push(`    ${template.roi}`);
+    }
+  }
+
+  lines.push('', 'Next actions:');
+  for (const action of report.nextActions) lines.push(`  - ${action}`);
+  lines.push('', `Example: ${report.exampleCommand}`, '');
+  return `${lines.join('\n')}\n`;
+}
+
+module.exports = {
+  AI_STACK_CATEGORY,
+  buildAiEngineeringStackGuardrailsPlan,
+  formatAiEngineeringStackGuardrailsPlan,
+  normalizeOptions,
+};

package/scripts/billing.js

@@ -6,6 +6,7 @@
 'use strict';
 
 const STRIPE_TIMEOUT_MS = 5000;
+const STRIPE_RECONCILIATION_SUMMARY_TIMEOUT_MS = 3500;
 function withTimeout(promise, ms = STRIPE_TIMEOUT_MS) {
   return Promise.race([
     promise,
@@ -1127,7 +1128,13 @@ function deriveRevenueEventFromPaidProviderEvent(entry = {}) {
 
 function loadResolvedRevenueEvents(options = {}) {
   const analyticsWindow = resolveAnalyticsWindow(options);
-  const extraRevenueEvents = Array.isArray(options.extraRevenueEvents) ? options.extraRevenueEvents : [];
+  const extraRevenueEvents = Array.isArray(options.extraRevenueEvents)
+    ? filterEntriesForWindow(
+      options.extraRevenueEvents,
+      analyticsWindow,
+      (entry) => entry && entry.timestamp
+    )
+    : [];
   const revenueEvents = filterEntriesForWindow(
     loadRevenueLedger(),
     analyticsWindow,
@@ -2371,7 +2378,12 @@ function getBillingSummary(options = {}) {
 
 async function getBillingSummaryLive(options = {}) {
   try {
-    const extraRevenueEvents = await listStripeReconciledRevenueEvents().catch(() => []);
+    const reconciliationTimeoutMs = normalizeInteger(options.stripeReconciliationTimeoutMs)
+      || STRIPE_RECONCILIATION_SUMMARY_TIMEOUT_MS;
+    const extraRevenueEvents = await withTimeout(
+      listStripeReconciledRevenueEvents(),
+      reconciliationTimeoutMs
+    ).catch(() => []);
     return getBillingSummary({
       ...options,
       extraRevenueEvents,
@@ -2527,10 +2539,10 @@ function buildCheckoutSessionPayload({ successUrl, cancelUrl, customerEmail, che
       packId: pack ? pack.id : null,
       credits: pack ? pack.credits : null,
     }),
-    // 7-day free trial for subscriptions — don't require card upfront
+    // Keep the trial, but require a payment method so trials can convert without dunning.
     ...(pack ? {} : {
       subscription_data: { trial_period_days: 7 },
-      payment_method_collection: 'if_required',
+      payment_method_collection: 'always',
     }),
   };
 

package/scripts/chatgpt-ads-readiness-pack.js

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const SOURCE = Object.freeze({
+  searchEngineLandUrl: 'https://searchengineland.com/advertisers-test-chatgpt-ads-manager-475114',
+  openAiAdsHelpUrl: 'https://help.openai.com/articles/20001047-ads-in-chatgpt',
+  openAiAdvertisersUrl: 'https://openai.com/advertisers',
+  title: 'Advertisers test ChatGPT Ads Manager',
+  observedAt: '2026-04-22',
+});
+
+function normalizeText(value) {
+  if (value === undefined || value === null) return '';
+  return String(value).trim();
+}
+
+function splitList(value) {
+  if (Array.isArray(value)) return value.map(String).map((item) => item.trim()).filter(Boolean);
+  return String(value || '').split(',').map((item) => item.trim()).filter(Boolean);
+}
+
+function parseNumber(value, fallback = 0) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+function normalizeOptions(raw = {}) {
+  return {
+    offer: normalizeText(raw.offer) || 'ThumbGate Pro and Workflow Hardening Sprint',
+    audience: normalizeText(raw.audience) || 'AI coding teams and developers comparing agent governance tools',
+    budget: parseNumber(raw.budget || raw['test-budget'], 500),
+    keywords: splitList(raw.keywords || raw.queries).length
+      ? splitList(raw.keywords || raw.queries)
+      : [
+        'AI coding agent keeps repeating mistakes',
+        'Claude Code pre tool use hook',
+        'Cursor agent guardrails',
+        'AI agent verification before PR',
+        'agent governance for coding teams',
+      ],
+    proofLinks: splitList(raw.proofLinks || raw['proof-links']).length
+      ? splitList(raw.proofLinks || raw['proof-links'])
+      : [
+        'https://github.com/IgorGanapolsky/ThumbGate/blob/main/docs/VERIFICATION_EVIDENCE.md',
+        'https://github.com/IgorGanapolsky/ThumbGate/blob/main/docs/COMMERCIAL_TRUTH.md',
+      ],
+  };
+}
+
+function buildAdGroups(options) {
+  return [
+    {
+      id: 'agent-governance-intent',
+      theme: 'developers asking how to make AI coding agents safer',
+      keywords: options.keywords.filter((keyword) => /agent|guardrail|governance|verification/i.test(keyword)).slice(0, 8),
+      landingPage: 'https://thumbgate.ai/guide?utm_source=chatgpt_ads&utm_medium=paid_ai&utm_campaign=agent_governance_intent',
+      primaryCta: 'Install the proof-backed guide',
+    },
+    {
+      id: 'workflow-hardening-intent',
+      theme: 'teams describing repeated autonomous-agent workflow failures',
+      keywords: [
+        'AI agent made same mistake again',
+        'coding agent opened bad PR',
+        'agent changed production without approval',
+        'AI workflow hardening sprint',
+      ],
+      landingPage: 'https://thumbgate.ai/?utm_source=chatgpt_ads&utm_medium=paid_ai&utm_campaign=workflow_hardening_intent#workflow-sprint-intake',
+      primaryCta: 'Book one workflow hardening sprint',
+    },
+  ];
+}
+
+function buildCreative(options) {
+  return [
+    {
+      id: 'proof-before-pr',
+      headline: 'Stop AI agents before repeat mistakes become PRs.',
+      body: 'ThumbGate turns feedback into pre-action gates for Claude Code, Cursor, Codex, Gemini CLI, and MCP agents. Require proof before risky tool calls or completion claims.',
+      proofRequired: options.proofLinks,
+    },
+    {
+      id: 'workflow-sprint',
+      headline: 'One repeated agent failure. One hardened workflow.',
+      body: 'Use ThumbGate to capture the mistake, retrieve the lesson, enforce the gate, and show verification evidence before the next autonomous change.',
+      proofRequired: options.proofLinks,
+    },
+  ];
+}
+
+function buildMeasurementPlan(options) {
+  return {
+    budget: options.budget,
+    primaryConversion: 'workflow_sprint_intake_or_pro_checkout_start',
+    guardrailMetrics: [
+      { id: 'landing_claim_proof_rate', target: '1.00' },
+      { id: 'cost_per_qualified_intake', target: '<= budget / 2' },
+      { id: 'proof_link_click_rate', target: '>= 0.05' },
+      { id: 'unsupported_ad_claims', target: '0' },
+    ],
+    attributionParams: {
+      utm_source: 'chatgpt_ads',
+      utm_medium: 'paid_ai',
+      utm_campaign: 'agent_governance_or_workflow_hardening',
+    },
+  };
+}
+
+function buildChatgptAdsReadinessPack(rawOptions = {}) {
+  const options = normalizeOptions(rawOptions);
+  const adGroups = buildAdGroups(options);
+  return {
+    name: 'thumbgate-chatgpt-ads-readiness-pack',
+    source: SOURCE,
+    status: 'ready_for_interest_signup',
+    offer: options.offer,
+    audience: options.audience,
+    strategy: {
+      channelThesis: 'If ChatGPT Ads Manager becomes self-serve, high-intent conversational queries can capture developers at the moment they are asking how to trust or govern AI agents.',
+      trustBoundary: 'OpenAI states ads are separate from answers and clearly labeled, so the campaign must win with proof-backed landing pages rather than implying answer influence.',
+      firstMove: 'Submit advertiser interest, prepare exact-match intent clusters, and route traffic to guide or workflow sprint pages with proof links.',
+    },
+    adGroups,
+    creative: buildCreative(options),
+    measurement: buildMeasurementPlan(options),
+    launchChecklist: [
+      'Submit interest at openai.com/advertisers.',
+      'Create a ChatGPT ads UTM namespace before first spend.',
+      'Use guide landing page for self-serve developer intent.',
+      'Use workflow sprint intake for high-risk team workflow pain.',
+      'Block unsupported claims in ad copy and landing pages.',
+      'Compare paid AI traffic against organic AI-search visibility before scaling budget.',
+    ],
+    marketingAngle: {
+      headline: 'ChatGPT ads are a paid surface for the exact moment developers ask how to trust agents.',
+      subhead: 'ThumbGate should be ready with proof-backed copy, intent clusters, and conversion routes before self-serve inventory gets crowded.',
+      replyDraft: 'If ChatGPT Ads Manager becomes self-serve, ThumbGate should test it early but stay evidence-first: bid on agent-governance pain, route to the setup guide or workflow sprint, and never imply ads influence ChatGPT answers. The wedge is proof-backed trust at the moment someone asks how to make agents safer.',
+    },
+  };
+}
+
+function formatChatgptAdsReadinessPack(report) {
+  const lines = [
+    '',
+    'ThumbGate ChatGPT Ads Readiness Pack',
+    '-'.repeat(38),
+    `Status  : ${report.status}`,
+    `Offer   : ${report.offer}`,
+    `Audience: ${report.audience}`,
+    `Source  : ${report.source.searchEngineLandUrl}`,
+    '',
+    'Ad groups:',
+  ];
+  for (const group of report.adGroups) {
+    lines.push(`  - ${group.id}: ${group.theme}`);
+    lines.push(`    Landing: ${group.landingPage}`);
+  }
+  lines.push('', 'Launch checklist:');
+  for (const item of report.launchChecklist) lines.push(`  - ${item}`);
+  lines.push('', `Reply draft: ${report.marketingAngle.replyDraft}`, '');
+  return `${lines.join('\n')}\n`;
+}
+
+function writeChatgptAdsReadinessPack(outputDir = path.join(__dirname, '..', 'docs', 'marketing'), options = {}) {
+  const report = buildChatgptAdsReadinessPack(options);
+  fs.mkdirSync(outputDir, { recursive: true });
+  const jsonPath = path.join(outputDir, 'chatgpt-ads-readiness-pack.json');
+  const markdownPath = path.join(outputDir, 'chatgpt-ads-readiness-pack.md');
+  fs.writeFileSync(jsonPath, `${JSON.stringify(report, null, 2)}\n`);
+  fs.writeFileSync(markdownPath, formatChatgptAdsReadinessPack(report));
+  return { report, jsonPath, markdownPath };
+}
+
+module.exports = {
+  SOURCE,
+  buildAdGroups,
+  buildChatgptAdsReadinessPack,
+  buildCreative,
+  buildMeasurementPlan,
+  formatChatgptAdsReadinessPack,
+  normalizeOptions,
+  writeChatgptAdsReadinessPack,
+};
+
+function isCliInvocation(argv = process.argv) {
+  return Boolean(argv[1] && path.resolve(argv[1]) === __filename);
+}
+
+if (isCliInvocation()) {
+  const { jsonPath, markdownPath } = writeChatgptAdsReadinessPack();
+  console.log(JSON.stringify({ jsonPath, markdownPath }, null, 2));
+}