thumbgate 1.14.1 → 1.16.0

package/scripts/document-workflow-governance.js

@@ -0,0 +1,62 @@
+'use strict';
+
+function buildDocumentWorkflowPlan(options = {}) {
+  const provider = options.provider || 'secure_content_layer';
+  const workflow = options.workflow || 'document_intake_routing';
+
+  return {
+    workflow,
+    provider,
+    steps: [
+      'discover eligible folders through approved connector scope',
+      'extract document metadata inside sandbox',
+      'classify document type with structured output',
+      'route document to approved destination',
+      'write audit event for every read, extraction, decision, and route',
+    ],
+    zeroTrust: {
+      leastPrivilegeScopes: true,
+      credentialsOutsideSandbox: true,
+      noRawDocumentExportByDefault: true,
+      perFolderApproval: true,
+    },
+    requiredEvidence: [
+      'connector scope',
+      'source document id',
+      'classification result',
+      'route destination',
+      'audit event id',
+      'sandbox manifest',
+    ],
+    gates: [
+      'block routing when connector scope is missing',
+      'block raw content export unless explicitly approved',
+      'block completion claims without audit event id',
+      'require human review for legal, financial, medical, or HR documents',
+    ],
+  };
+}
+
+function evaluateDocumentWorkflowRun(run = {}) {
+  const issues = [];
+  if (!run.connectorScope) issues.push('missing_connector_scope');
+  if (!run.sourceDocumentId) issues.push('missing_source_document_id');
+  if (!run.classification) issues.push('missing_classification');
+  if (!run.routeDestination) issues.push('missing_route_destination');
+  if (!run.auditEventId) issues.push('missing_audit_event_id');
+  if (!run.sandboxManifest) issues.push('missing_sandbox_manifest');
+  if (run.rawExport && !run.rawExportApproved) issues.push('raw_export_requires_approval');
+  if (['legal', 'financial', 'medical', 'hr'].includes(String(run.classification).toLowerCase()) && !run.humanReviewed) {
+    issues.push('sensitive_document_human_review_required');
+  }
+
+  return {
+    decision: issues.length ? 'deny' : 'allow',
+    issues,
+  };
+}
+
+module.exports = {
+  buildDocumentWorkflowPlan,
+  evaluateDocumentWorkflowRun,
+};

package/scripts/enterprise-agent-rollout.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+'use strict';
+
+function buildEnterpriseAgentRollout(input = {}) {
+  const industry = input.industry || 'enterprise software';
+  return {
+    program: 'ThumbGate Enterprise Agent Acceleration',
+    industry,
+    operatingModel: {
+      forwardDeployedEngineer: true,
+      humanInTheLead: true,
+      domainExpertsRequired: true,
+      sovereignDeploymentOption: true,
+    },
+    phases: [
+      { id: 'discover', outcome: 'rank workflows by measurable business value and risk' },
+      { id: 'prototype', outcome: 'ship one governed agent with evidence and rollback' },
+      { id: 'scale', outcome: 'publish reusable agent catalog and approval policies' },
+      { id: 'operate', outcome: 'review traces, ROI, incidents, and policy drift weekly' },
+    ],
+    governance: [
+      'human oversight for high-stakes recommendations',
+      'sovereign data boundary when required',
+      'agent catalog with owner and allowed tools',
+      'decision journal for every business-critical action',
+      'measurable outcome before expansion',
+    ],
+    metrics: ['cycle_time_saved', 'blocked_risky_actions', 'approved_agent_runs', 'business_value_cents', 'incident_rate'],
+  };
+}
+
+module.exports = {
+  buildEnterpriseAgentRollout,
+};

package/scripts/experience-replay-governance.js

@@ -0,0 +1,69 @@
+'use strict';
+
+function buildExperienceReplayPolicy(options = {}) {
+  const maxStalenessHours = Number.isFinite(options.maxStalenessHours) ? options.maxStalenessHours : 24;
+  const replayRatio = Number.isFinite(options.replayRatio) ? options.replayRatio : 0.25;
+  const minEntropy = Number.isFinite(options.minEntropy) ? options.minEntropy : 0.65;
+
+  return {
+    policyId: 'feedback_experience_replay',
+    purpose: 'Reuse high-signal feedback trajectories without letting stale lessons dominate training.',
+    buffer: {
+      strategy: 'fifo_with_quality_filters',
+      maxStalenessHours,
+      replayRatio,
+      sampleWithoutRemoval: true,
+    },
+    filters: [
+      'redacted',
+      'source_feedback_id_present',
+      'outcome_evidence_present',
+      'not_contradicted_by_newer_lesson',
+      'not_low_confidence_or_vague_feedback',
+    ],
+    monitors: {
+      maxStalenessHours,
+      minEntropy,
+      compareAgainstFreshOnly: true,
+      metrics: ['gate_precision', 'gate_recall', 'unsupported_claim_rate', 'policy_entropy', 'compute_saved_percent'],
+    },
+  };
+}
+
+function evaluateReplayCandidate(candidate = {}, policy = buildExperienceReplayPolicy()) {
+  const issues = [];
+  if (!candidate.sourceFeedbackId) issues.push('missing_source_feedback_id');
+  if (!candidate.redacted) issues.push('redaction_required');
+  if (!candidate.outcomeEvidence) issues.push('missing_outcome_evidence');
+  if (candidate.contradictedByNewerLesson) issues.push('contradicted_by_newer_lesson');
+  if (candidate.vagueFeedback) issues.push('vague_feedback_not_replayable');
+
+  const ageHours = Number(candidate.ageHours || 0);
+  if (ageHours > policy.buffer.maxStalenessHours) issues.push('stale_replay_sample');
+
+  return {
+    decision: issues.length ? 'reject' : 'accept',
+    issues,
+    replayWeight: issues.length ? 0 : Math.min(policy.buffer.replayRatio, Number(candidate.qualityScore || 1)),
+  };
+}
+
+function evaluateReplayRun(run = {}, policy = buildExperienceReplayPolicy()) {
+  const issues = [];
+  if (Number(run.replayRatio || 0) > 0.5) issues.push('replay_ratio_too_high');
+  if (Number(run.policyEntropy || 0) < policy.monitors.minEntropy) issues.push('policy_entropy_too_low');
+  if (!run.freshOnlyBaseline) issues.push('missing_fresh_only_baseline');
+  if (!run.computeSavedPercent && run.computeSavedPercent !== 0) issues.push('missing_compute_saved_metric');
+
+  return {
+    decision: issues.length ? 'warn' : 'allow',
+    issues,
+    computeEfficient: Number(run.computeSavedPercent || 0) > 0 && Number(run.policyEntropy || 0) >= policy.monitors.minEntropy,
+  };
+}
+
+module.exports = {
+  buildExperienceReplayPolicy,
+  evaluateReplayCandidate,
+  evaluateReplayRun,
+};

package/scripts/export-hf-dataset.js

@@ -123,7 +123,7 @@ function buildPreferenceRow(pair, index) {
 function buildDatasetInfo({ traceCount, preferenceCount, exportedAt }) {
   return {
     dataset_info: {
-      description: 'Agent traces and DPO preference pairs from ThumbGate — pre-action gates for AI coding agents. Contains real-world tool call feedback, failure patterns, and learned corrections.',
+      description: 'Agent traces and DPO preference pairs from ThumbGate — pre-action checks for AI coding agents. Contains real-world tool call feedback, failure patterns, and learned corrections.',
       citation: '',
       homepage: 'https://github.com/IgorGanapolsky/ThumbGate',
       license: 'MIT',

package/scripts/feedback-loop.js

@@ -9,6 +9,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const { loadOptionalModule } = require('./private-core-boundary');
 const {
   resolveFeedbackAction,
   prepareForStorage,
@@ -25,7 +26,13 @@ const {
 const { recordAction, attributeFeedback } = require('./feedback-attribution');
 const {
   distillFeedbackHistory,
-} = require('./feedback-history-distiller');
+} = loadOptionalModule('./feedback-history-distiller', () => ({
+  distillFeedbackHistory: () => ({
+    inferredFields: {},
+    conversationWindow: [],
+    source: 'public-shell-fallback',
+  }),
+}));
 const {
   extractFilePaths: extractConversationPaths,
   extractErrors: extractConversationErrors,
@@ -41,6 +48,11 @@ const {
   buildFeedbackPathsFromDir,
   getFeedbackPaths: resolveFeedbackPaths,
 } = require('./feedback-paths');
+const {
+  reflect,
+} = loadOptionalModule('./reflector-agent', () => ({
+  reflect: () => null,
+}));
 
 const AUDIT_TRAIL_TAG = 'audit-trail';
 
@@ -106,6 +118,12 @@ const DOMAIN_CATEGORIES = [
 const HOME = process.env.HOME || process.env.USERPROFILE || '';
 const pendingBackgroundSideEffects = new Set();
 
+function loadReflectorAgentModule() {
+  const modulePath = path.resolve(__dirname, 'reflector-agent.js');
+  if (!fs.existsSync(modulePath)) return null;
+  return require(modulePath);
+}
+
 /**
  * Update the statusline cache with latest lesson info after feedback capture.
  * The statusline.sh script reads this cache to display lesson context in Claude Code's status bar.
@@ -197,7 +215,9 @@ function getSelfAuditModule() {
 
 function getDelegationRuntimeModule() {
   try {
-    return require('./delegation-runtime');
+    const modulePath = path.resolve(__dirname, 'delegation-runtime.js');
+    if (!fs.existsSync(modulePath)) return null;
+    return require(modulePath);
   } catch {
     return null;
   }
@@ -261,6 +281,7 @@ function normalizeAnalysisShape(analysis = {}) {
     delegation: analysis.delegation || null,
     boostedRisk: analysis.boostedRisk || null,
     recommendations: Array.isArray(analysis.recommendations) ? analysis.recommendations : [],
+    actionableRemediations: Array.isArray(analysis.actionableRemediations) ? analysis.actionableRemediations : [],
     source: analysis.source,
     byDomain: Array.isArray(analysis.byDomain) ? analysis.byDomain : [],
     byImportance: Array.isArray(analysis.byImportance) ? analysis.byImportance : [],
@@ -564,7 +585,7 @@ function saveSummary(summary) {
 
 // ============================================================
 // ML Side-Effect Helpers — Sequence Tracking (ML-03) and
-// Diversity Tracking (ML-04). Inline per Subway architecture.
+// Diversity Tracking (ML-04). Inline feedback-loop implementation.
 // ============================================================
 
 function inferDomain(tags, context) {
@@ -943,7 +964,6 @@ function captureFeedback(params) {
   let reflection = null;
   if (signal === 'negative' && Array.isArray(params.conversationWindow) && params.conversationWindow.length >= 2) {
     try {
-      const { reflect } = require('./reflector-agent');
       reflection = reflect({
         conversationWindow: params.conversationWindow,
         context: inferredContext,
@@ -1167,6 +1187,15 @@ function captureFeedback(params) {
     timestamp: now,
   };
 
+  // Stamp a cross-session canonical hash on every memory record so future
+  // captures can short-circuit dedup without re-canonicalizing legacy entries.
+  // See scripts/lesson-canonical.js for the normalization contract.
+  try {
+    const { canonicalHash } = require('./lesson-canonical');
+    const hash = canonicalHash(memoryRecord);
+    if (hash) memoryRecord.canonicalHash = hash;
+  } catch (_canonErr) { /* canonical hashing is non-blocking */ }
+
   // Bayesian Belief Update (Project Bayes)
   try {
     const { updateBelief, shouldPrune } = require('./belief-update');
@@ -1210,14 +1239,49 @@ function captureFeedback(params) {
       const merged = mergeIntoExisting(MEMORY_LOG_PATH, similar.match, memoryRecord, feedbackEvent);
       synthesisResult = { action: 'merged', existingId: similar.match.id, similarity: similar.similarity, occurrences: merged.occurrences };
 
-      // Auto-promote if threshold reached
+      // Auto-promote if threshold reached, but only after the rule
+      // validator (scripts/rule-validator.js) confirms the proposed trigger
+      // matches the seed lesson and has acceptable precision on recent
+      // overlapping-tag events. This plugs the Autogenesis "validate
+      // before integrate" phase that was missing from the original
+      // promotion path — previously every threshold-crossing lesson
+      // shipped a rule regardless of whether it would over-block positives.
       if (shouldAutoPromote(merged)) {
         const rule = synthesizePreventionRule(merged);
-        synthesisResult.autoPromoted = true;
+        let validation = null;
+        try {
+          const { validateProposedRule } = require('./rule-validator');
+          // Sample the last 50 memory events across both signals. Using
+          // memory-log rather than feedback-log because memory records
+          // carry the richer title/content fields the validator scores
+          // against, and findSimilarLesson already reads this file.
+          const recentEvents = readJSONL(MEMORY_LOG_PATH).slice(-50);
+          validation = validateProposedRule(rule, {
+            seedLesson: merged,
+            recentEvents,
+          });
+          rule.validation = validation;
+        } catch (_valErr) {
+          // Validator failure must not block the existing pipeline; fall
+          // back to the legacy "promote unconditionally" behavior.
+          validation = { shouldPromote: true, reason: 'validator_error', error: _valErr.message };
+          rule.validation = validation;
+        }
+
         synthesisResult.preventionRule = rule;
-        // Store the synthesized rule
-        const rulesPath = path.join(path.dirname(MEMORY_LOG_PATH), 'synthesized-rules.jsonl');
-        appendJSONLLocal(rulesPath, rule);
+        synthesisResult.validation = validation;
+        if (validation.shouldPromote) {
+          synthesisResult.autoPromoted = true;
+          // Store the synthesized rule
+          const rulesPath = path.join(path.dirname(MEMORY_LOG_PATH), 'synthesized-rules.jsonl');
+          appendJSONLLocal(rulesPath, rule);
+        } else {
+          // Park rejected rules in a side log so operators can audit them.
+          synthesisResult.autoPromoted = false;
+          synthesisResult.rejectionReason = validation.reason;
+          const rejectedPath = path.join(path.dirname(MEMORY_LOG_PATH), 'rejected-rules.jsonl');
+          appendJSONLLocal(rejectedPath, rule);
+        }
       }
     } else {
       // No similar lesson — check exact duplicate, then store
@@ -1469,11 +1533,22 @@ function analyzeFeedback(logPath) {
   };
 
   const recommendations = [];
+  // Structured counterpart to `recommendations` — machine-actionable shape so
+  // hooks/agents can act on each item without regex-parsing prose strings.
+  // Each entry: { type, target, evidence, action, rationale }.
+  const actionableRemediations = [];
 
   for (const [skill, stat] of Object.entries(skills)) {
     const negRate = stat.total > 0 ? stat.negative / stat.total : 0;
     if (stat.total >= 3 && negRate >= 0.5) {
       recommendations.push(`IMPROVE skill '${skill}' (${stat.negative}/${stat.total} negative)`);
+      actionableRemediations.push({
+        type: 'skill-improve',
+        target: skill,
+        evidence: { positive: stat.positive, negative: stat.negative, total: stat.total, negativeRate: Math.round(negRate * 1000) / 1000 },
+        action: 'review-and-update-skill',
+        rationale: `Skill '${skill}' has ${stat.negative}/${stat.total} negative feedback events (${Math.round(negRate * 100)}% negative rate).`,
+      });
     }
   }
 
@@ -1481,14 +1556,35 @@ function analyzeFeedback(logPath) {
     const posRate = stat.total > 0 ? stat.positive / stat.total : 0;
     if (stat.total >= 3 && posRate >= 0.8) {
       recommendations.push(`REUSE pattern '${tag}' (${stat.positive}/${stat.total} positive)`);
+      actionableRemediations.push({
+        type: 'pattern-reuse',
+        target: tag,
+        evidence: { positive: stat.positive, negative: stat.negative, total: stat.total, positiveRate: Math.round(posRate * 1000) / 1000 },
+        action: 'replicate-pattern',
+        rationale: `Pattern '${tag}' has ${stat.positive}/${stat.total} positive feedback events (${Math.round(posRate * 100)}% positive rate).`,
+      });
     }
   }
 
   if (recent.length >= 10 && recentRate < approvalRate - 0.1) {
     recommendations.push('DECLINING trend in last 20 signals; tighten verification before response.');
+    actionableRemediations.push({
+      type: 'trend-declining',
+      target: 'recent-signals',
+      evidence: { recentRate, approvalRate, sampleSize: recent.length },
+      action: 'tighten-verification-before-response',
+      rationale: `Recent approval rate (${Math.round(recentRate * 100)}%) has dropped ≥10pp below lifetime (${Math.round(approvalRate * 100)}%).`,
+    });
   }
   if (trend === 'degrading') {
     recommendations.push(`DEGRADING 7d trend (${rate7d}) vs 30d (${rate30d}); increase prevention rule injection.`);
+    actionableRemediations.push({
+      type: 'trend-degrading',
+      target: '7d-window',
+      evidence: { rate7d, rate30d, delta: Math.round((rate7d - rate30d) * 1000) / 1000 },
+      action: 'increase-prevention-rule-injection',
+      rationale: `7d rate (${rate7d}) is below 30d rate (${rate30d}) by more than threshold.`,
+    });
   }
 
   let boostedRisk = null;
@@ -1499,9 +1595,23 @@ function analyzeFeedback(logPath) {
       if (boostedRisk) {
         boostedRisk.highRiskDomains.slice(0, 2).forEach((bucket) => {
           recommendations.push(`CHECK high-risk domain '${bucket.key}' (${bucket.highRisk}/${bucket.total} high-risk)`);
+          actionableRemediations.push({
+            type: 'high-risk-domain',
+            target: bucket.key,
+            evidence: { highRisk: bucket.highRisk, total: bucket.total, riskRate: bucket.riskRate },
+            action: 'audit-domain-failures',
+            rationale: `Domain '${bucket.key}' has ${bucket.highRisk}/${bucket.total} high-risk events (${Math.round((bucket.riskRate || 0) * 100)}% risk rate).`,
+          });
         });
         boostedRisk.highRiskTags.slice(0, 2).forEach((bucket) => {
           recommendations.push(`CHECK high-risk tag '${bucket.key}' (${bucket.highRisk}/${bucket.total} high-risk)`);
+          actionableRemediations.push({
+            type: 'high-risk-tag',
+            target: bucket.key,
+            evidence: { highRisk: bucket.highRisk, total: bucket.total, riskRate: bucket.riskRate },
+            action: 'audit-tag-failures',
+            rationale: `Tag '${bucket.key}' has ${bucket.highRisk}/${bucket.total} high-risk events (${Math.round((bucket.riskRate || 0) * 100)}% risk rate).`,
+          });
         });
       }
     }
@@ -1516,9 +1626,23 @@ function analyzeFeedback(logPath) {
       delegation = delegationRuntime.summarizeDelegation(paths.FEEDBACK_DIR);
       if (delegation.attemptCount >= 3 && delegation.verificationFailureRate >= 0.5) {
         recommendations.push(`REDUCE delegation: verification failure rate is ${Math.round(delegation.verificationFailureRate * 100)}%`);
+        actionableRemediations.push({
+          type: 'delegation-reduce',
+          target: 'verification-failure-rate',
+          evidence: { verificationFailureRate: delegation.verificationFailureRate, attemptCount: delegation.attemptCount },
+          action: 'reduce-delegation-use',
+          rationale: `Delegation verification failure rate is ${Math.round(delegation.verificationFailureRate * 100)}% across ${delegation.attemptCount} attempts.`,
+        });
       }
       if (delegation.avoidedDelegationCount >= 3) {
         recommendations.push(`REVIEW delegation policy: ${delegation.avoidedDelegationCount} handoff starts were blocked before execution`);
+        actionableRemediations.push({
+          type: 'delegation-policy-review',
+          target: 'handoff-blocks',
+          evidence: { avoidedDelegationCount: delegation.avoidedDelegationCount },
+          action: 'review-delegation-policy',
+          rationale: `${delegation.avoidedDelegationCount} handoff starts were blocked before execution.`,
+        });
       }
     }
   } catch {
@@ -1526,6 +1650,13 @@ function analyzeFeedback(logPath) {
   }
   diagnostics.categories.slice(0, 2).forEach((bucket) => {
     recommendations.push(`DIAGNOSE '${bucket.key}' failures (${bucket.count})`);
+    actionableRemediations.push({
+      type: 'diagnose-failure-category',
+      target: bucket.key,
+      evidence: { count: bucket.count },
+      action: 'investigate-failure-category',
+      rationale: `Failure category '${bucket.key}' has ${bucket.count} diagnosed events.`,
+    });
   });
 
   return normalizeAnalysisShape({
@@ -1547,6 +1678,7 @@ function analyzeFeedback(logPath) {
     delegation,
     boostedRisk,
     recommendations,
+    actionableRemediations,
   });
 }
 

package/scripts/feedback-to-rules.js

@@ -253,7 +253,7 @@ Constraints:
 - Return ONLY the JSON array — no markdown, no explanation outside the array.`;
 
 async function analyzeWithLLM(entries) {
-  const { isAvailable, callClaude, MODELS } = require('./llm-client');
+  const { isAvailable, callClaudeJson, MODELS } = require('./llm-client');
   if (!isAvailable()) return null;
 
   const negativeEntries = entries
@@ -276,34 +276,28 @@ async function analyzeWithLLM(entries) {
     return entry;
   }).join('\n\n');
 
-  const raw = await callClaude({
+  const parsed = await callClaudeJson({
     systemPrompt: LLM_RULES_SYSTEM_PROMPT,
     userPrompt: `Analyze these ${negativeEntries.length} negative feedback entries and generate prevention rules:\n\n${batch}`,
     model: MODELS.SMART,
     maxTokens: 2048,
+    cache: true,
   });
 
-  if (!raw) return null;
-
-  try {
-    const parsed = JSON.parse(raw);
-    if (!Array.isArray(parsed)) return null;
-
-    return parsed
-      .filter((r) => r.pattern && r.action && r.message && r.severity)
-      .slice(0, 10)
-      .map((r) => ({
-        pattern: r.pattern,
-        count: negativeEntries.length,
-        severity: ['critical', 'high', 'medium'].includes(r.severity) ? r.severity : 'medium',
-        hasHighRisk: r.severity === 'critical',
-        suggestedRule: r.message,
-        reasoning: r.reasoning || '',
-        source: 'llm-analysis',
-      }));
-  } catch {
-    return null;
-  }
+  if (!Array.isArray(parsed)) return null;
+
+  return parsed
+    .filter((r) => r.pattern && r.action && r.message && r.severity)
+    .slice(0, 10)
+    .map((r) => ({
+      pattern: r.pattern,
+      count: negativeEntries.length,
+      severity: ['critical', 'high', 'medium'].includes(r.severity) ? r.severity : 'medium',
+      hasHighRisk: r.severity === 'critical',
+      suggestedRule: r.message,
+      reasoning: r.reasoning || '',
+      source: 'llm-analysis',
+    }));
 }
 
 if (require.main === module) {

package/scripts/gates-engine.js

@@ -5,6 +5,7 @@ const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
 const { execSync, execFileSync } = require('child_process');
+const { loadOptionalModule } = require('./private-core-boundary');
 
 const { isProTier, FREE_TIER_MAX_GATES } = require('./rate-limiter');
 const {
@@ -1976,12 +1977,9 @@ function buildRecentCorrectiveActionsContext(options = {}) {
 function buildRelevantLessonContext(toolName, toolInput) {
   if (!toolName) return null;
 
-  let retrieveRelevantLessons;
-  try {
-    ({ retrieveRelevantLessons } = require('./lesson-retrieval'));
-  } catch {
-    return null;
-  }
+  const { retrieveRelevantLessons } = loadOptionalModule('./lesson-retrieval', () => ({
+    retrieveRelevantLessons: () => [],
+  }));
 
   // Extract a searchable action context from the tool input
   const actionContext = extractActionContext(toolName, toolInput);

package/scripts/growth-campaigns.js

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+'use strict';
+
+function buildCreatorGrowthCampaign(input = {}) {
+  const appUrl = input.appUrl || 'https://thumbgate-production.up.railway.app';
+  const webinarTitle = input.webinarTitle || 'Stop AI Agents From Repeating Expensive Mistakes';
+  const offerCode = input.offerCode || 'AGENTGATES';
+  return {
+    campaignId: 'creator_webinar_agent_governance',
+    channelFit: ['beehiiv', 'linkedin', 'newsletter', 'webinar', 'youtube'],
+    audience: 'founders, engineering managers, AI automators, and creator-operators shipping with coding agents',
+    webinar: {
+      title: webinarTitle,
+      promise: 'In 30 minutes, see how a thumbs-down turns into a pre-action gate that blocks the same agent mistake next time.',
+      demoFlow: [
+        'Show a risky agent action before ThumbGate.',
+        'Capture corrective feedback with context.',
+        'Regenerate the prevention rule.',
+        'Replay the action and show the gate blocking it.',
+        'Export the decision journal and proof report.',
+      ],
+      cta: `${appUrl}/#workflow-sprint-intake?utm_source=beehiiv&utm_campaign=creator_webinar_agent_governance&offer=${offerCode}`,
+    },
+    paywall: {
+      freeMeter: 2,
+      paidTrial: '$1 for 14 days',
+      paidContent: [
+        'Routine-ready security audit prompt',
+        'CRE prompt review checklist',
+        'Data Table Agent schema planner template',
+        'Workspace Agent approval-policy checklist',
+      ],
+    },
+    posts: [
+      {
+        platform: 'linkedin',
+        text: 'AI agents are becoming scheduled coworkers. The missing layer is enforcement: approvals, evidence, rollback, and memory that blocks repeat mistakes. ThumbGate turns feedback into pre-action gates.',
+      },
+      {
+        platform: 'newsletter',
+        text: 'This week: how to stop prompting and hoping. Treat prompts as runtime programs, require evidence before tool actions, and use ThumbGate to block known-bad agent patterns.',
+      },
+    ],
+  };
+}
+
+module.exports = {
+  buildCreatorGrowthCampaign,
+};