thumbgate 1.8.0 → 1.10.1

package/scripts/autoresearch-runner.js

@@ -0,0 +1,228 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * Autoresearch Runner (AUTORESEARCH-02)
+ *
+ * Karpathy-inspired self-optimizing loop for the ThumbGate feedback studio.
+ * Each iteration: mutate local evolution state → run primary + holdout checks
+ * → measure score → keep/discard with rollback snapshots.
+ *
+ * The runner never rewrites tracked source files. It mutates the local
+ * evolution-state overlay, evaluates in place, and only persists accepted
+ * settings plus rollback snapshots.
+ *
+ * Mutation targets (in priority order):
+ *   1. Thompson Sampling priors (HALF_LIFE_DAYS, DECAY_FLOOR)
+ *   2. Prevention rule thresholds (minOccurrences)
+ *   3. Verification loop retries (MAX_RETRIES)
+ *   4. DPO temperature (DPO_BETA)
+ *
+ * Score function: command pass rate × approval weighting, with holdout gating.
+ *
+ * Zero external dependencies.
+ *
+ * Exports: runIteration, runLoop, scoreSuite, MUTATION_TARGETS
+ */
+
+const {
+  getProgress,
+} = require('./experiment-tracker');
+const { buildResearchBrief } = require('./hf-papers');
+const {
+  EVOLUTION_TARGETS,
+  parseCommandScore,
+  runWorkspaceEvolution,
+} = require('./workspace-evolver');
+
+// ---------------------------------------------------------------------------
+// Mutation Targets
+// ---------------------------------------------------------------------------
+
+const MUTATION_TARGETS = EVOLUTION_TARGETS;
+
+// ---------------------------------------------------------------------------
+// Score Function
+// ---------------------------------------------------------------------------
+
+/**
+ * Score a test suite run. Returns a number in [0, 1].
+ *
+ * @param {object} params
+ * @param {string} params.testOutput - stdout from test run
+ * @param {number} [params.approvalRate] - Current approval rate from feedback
+ * @returns {{ score: number, testPassRate: number, details: object }}
+ */
+function scoreSuite(params) {
+  return parseCommandScore(params.testOutput || '', 0, typeof params.approvalRate === 'number' ? params.approvalRate : 0.5);
+}
+
+// ---------------------------------------------------------------------------
+// Single Iteration
+// ---------------------------------------------------------------------------
+
+/**
+ * Run one autoresearch iteration.
+ *
+ * 1. Pick a random mutation target
+ * 2. Read current value, compute a random neighbor
+ * 3. Run the test suite in a tmp env with the mutation
+ * 4. Score and keep/discard via experiment tracker
+ *
+ * @param {object} [opts]
+ * @param {string} [opts.targetName] - Force a specific mutation target
+ * @param {number} [opts.nextValue] - Force the candidate value instead of a random neighbor
+ * @param {string} [opts.testCommand] - Override test command (default: npm test)
+ * @param {string[]} [opts.holdoutCommands] - Optional holdout commands required for acceptance
+ * @param {number} [opts.timeoutMs] - Test timeout in ms (default: 120000)
+ * @param {string} [opts.cwd] - Working directory for evaluation commands
+ * @param {string} [opts.researchQuery] - Optional external research query
+ * @param {number} [opts.paperLimit] - Max papers to ingest for research context
+ * @param {Function} [opts.fetchImpl] - Optional fetch implementation override
+ * @param {Function} [opts.searchPapersImpl] - Optional paper search override
+ * @returns {Promise<object>} experiment result
+ */
+async function runIteration(opts = {}) {
+  const options = opts || {};
+  const timeoutMs = options.timeoutMs || 120000;
+  const testCommand = options.testCommand || 'npm test';
+  const research = options.researchQuery
+    ? await buildResearchBrief({
+      query: options.researchQuery,
+      limit: options.paperLimit,
+      fetchImpl: options.fetchImpl,
+      searchPapersImpl: options.searchPapersImpl,
+      template: 'autoresearch-brief',
+    })
+    : null;
+
+  const result = runWorkspaceEvolution({
+    targetName: options.targetName,
+    nextValue: options.nextValue,
+    primaryCommands: [testCommand],
+    holdoutCommands: options.holdoutCommands || [],
+    timeoutMs,
+    cwd: options.cwd,
+    hypothesisSuffix: research ? `Research query: ${research.query}` : null,
+    additionalMetrics: {
+      researchQuery: research ? research.query : null,
+      researchPackId: research ? research.packId : null,
+      researchPaperIds: research ? research.citations.map((citation) => citation.paperId).filter(Boolean) : [],
+    },
+  });
+
+  return result;
+}
+
+// ---------------------------------------------------------------------------
+// Multi-Iteration Loop
+// ---------------------------------------------------------------------------
+
+/**
+ * Run N autoresearch iterations.
+ *
+ * @param {object} params
+ * @param {number} params.iterations - Number of experiments to run
+ * @param {string} [params.targetName] - Force a specific mutation target
+ * @param {number} [params.nextValue] - Force the candidate value instead of a random neighbor
+ * @param {string} [params.testCommand] - Override test command
+ * @param {string[]} [params.holdoutCommands] - Optional holdout commands required for acceptance
+ * @param {number} [params.timeoutMs] - Per-iteration timeout
+ * @param {string} [params.cwd] - Working directory for evaluation commands
+ * @param {string} [params.researchQuery] - Optional external research query
+ * @param {number} [params.paperLimit] - Max papers to ingest for research context
+ * @param {Function} [params.fetchImpl] - Optional fetch implementation override
+ * @param {Function} [params.searchPapersImpl] - Optional paper search override
+ * @returns {Promise<object>} { results, progress }
+ */
+async function runLoop(params) {
+  const iterations = params.iterations || 1;
+  const results = [];
+
+  for (let i = 0; i < iterations; i++) {
+    console.log(`\n[autoresearch] Iteration ${i + 1}/${iterations}`);
+    try {
+      const result = await runIteration({
+        targetName: params.targetName,
+        nextValue: Number.isFinite(params.nextValue) ? params.nextValue : undefined,
+        testCommand: params.testCommand,
+        holdoutCommands: params.holdoutCommands,
+        timeoutMs: params.timeoutMs,
+        cwd: params.cwd,
+        researchQuery: params.researchQuery,
+        paperLimit: params.paperLimit,
+        fetchImpl: params.fetchImpl,
+        searchPapersImpl: params.searchPapersImpl,
+      });
+      results.push(result);
+      if (result.kept) {
+        console.log(`  ✓ KEPT: ${result.name} (delta: +${(result.delta || 0).toFixed(4)})`);
+      } else if (result.skipped) {
+        console.log(`  ⊘ SKIPPED: ${result.reason}`);
+      } else {
+        console.log(`  ✗ DISCARDED: ${result.reason}`);
+      }
+    } catch (err) {
+      console.error(`  ✗ ERROR: ${err.message}`);
+      results.push({ error: err.message });
+    }
+  }
+
+  const progress = getProgress();
+  console.log(`\n[autoresearch] Progress: ${progress.completed} experiments, ${progress.kept} kept (${progress.keepRate}%)`);
+  return { results, progress };
+}
+
+// ---------------------------------------------------------------------------
+// CLI
+// ---------------------------------------------------------------------------
+
+if (require.main === module) {
+  const args = {};
+  process.argv.slice(2).forEach((arg) => {
+    if (!arg.startsWith('--')) return;
+    const [key, ...rest] = arg.slice(2).split('=');
+    args[key] = rest.length > 0 ? rest.join('=') : true;
+  });
+
+  if (args.run) {
+    const iterations = Number(args.iterations || 1);
+    const testCommand = args['test-command'] || 'npm test';
+    const timeoutMs = Number(args.timeout || 120000);
+    const paperLimit = Number(args['paper-limit'] || 5);
+    const holdoutCommands = args.holdout ? [args.holdout] : [];
+    runLoop({
+      iterations,
+      targetName: args.target || null,
+      nextValue: args['next-value'] !== undefined ? Number(args['next-value']) : undefined,
+      testCommand,
+      holdoutCommands,
+      timeoutMs,
+      cwd: args.cwd || undefined,
+      researchQuery: args['research-query'] || null,
+      paperLimit,
+    }).catch((error) => {
+      console.error(error.message);
+      process.exit(1);
+    });
+  } else if (args.targets) {
+    console.log('Mutation targets:');
+    MUTATION_TARGETS.forEach((t) => {
+      console.log(`  ${t.name} (${t.type}): range [${t.range.join(', ')}], step ${t.step}`);
+    });
+  } else {
+    console.log(`Usage:
+  node scripts/autoresearch-runner.js --run [--iterations=5] [--target=half_life_days] [--next-value=8] [--test-command="npm test"] [--holdout="npm run self-heal:check"] [--timeout=120000] [--research-query="rank fusion"] [--paper-limit=5]
+  node scripts/autoresearch-runner.js --targets`);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Exports
+// ---------------------------------------------------------------------------
+
+module.exports = {
+  runIteration,
+  runLoop,
+  scoreSuite,
+  MUTATION_TARGETS,
+};

package/scripts/bayes-optimal-gate.js

@@ -0,0 +1,273 @@
+'use strict';
+
+/**
+ * scripts/bayes-optimal-gate.js
+ *
+ * Bayes-optimal decision layer for ThumbGate's pre-tool-use gate.
+ *
+ * Why this exists:
+ *   The legacy gate blocks a tool call when any matched lesson tag has a
+ *   heuristic risk score ≥ a global threshold. That is a "threshold on a
+ *   heuristic" rule, not a Bayes-optimal decision. It cannot express two
+ *   facts that matter in practice:
+ *     1. Different tags carry different empirical harm rates (a prior).
+ *     2. Mis-classification is asymmetric — letting a harmful `deploy-prod`
+ *        call through is far more expensive than briefly blocking a safe
+ *        lint fix. A single global threshold cannot reflect that.
+ *
+ * What this module provides:
+ *   - `computeBayesPosterior(...)` — P(harmful | tags) combining the trained
+ *     model's probability (if present), the base rate, and per-tag empirical
+ *     risk rates via a clipped Bayes-factor update.
+ *   - `bayesOptimalDecision(...)` — cost-weighted argmax over {block, allow}
+ *     using a configurable loss matrix. Block iff the expected loss of
+ *     allowing exceeds the expected loss of blocking.
+ *   - `computeBayesErrorRate(rows)` — the irreducible error floor of the
+ *     current feature set (tag signatures). Useful as a stopping rule when
+ *     tuning the scorer.
+ *
+ * No external deps. Pure functions; the only IO is an optional
+ * `config/enforcement.json` read inside `loadLossMatrix()`.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+// Baseline loss matrix. `default` applies when no tag-specific override
+// matches. Higher = more expensive. The asymmetry below reflects the
+// observed cost of real ThumbGate incidents: false-allow on a destructive
+// or production-facing action costs hours of recovery and credibility;
+// false-block costs the operator one explicit override flag.
+const DEFAULT_LOSS_MATRIX = {
+  falseAllow: {
+    default: 1.0,
+    'deploy-prod': 100.0,
+    'destructive': 50.0,
+    'secrets': 1000.0,
+    'force-push-main': 200.0,
+    'data-loss': 500.0,
+  },
+  falseBlock: {
+    default: 1.0,
+  },
+};
+
+const ENFORCEMENT_CONFIG_PATH = path.join(__dirname, '..', 'config', 'enforcement.json');
+
+/**
+ * Load the loss matrix from `config/enforcement.json` if present, otherwise
+ * return the baked-in default. Any parse/IO failure falls back to defaults —
+ * the Bayes gate must never deadlock the hook on a config problem.
+ */
+function loadLossMatrix(configPath = ENFORCEMENT_CONFIG_PATH) {
+  try {
+    if (!fs.existsSync(configPath)) return DEFAULT_LOSS_MATRIX;
+    const raw = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    if (!raw || typeof raw !== 'object' || !raw.lossMatrix) return DEFAULT_LOSS_MATRIX;
+    return {
+      falseAllow: { ...DEFAULT_LOSS_MATRIX.falseAllow, ...(raw.lossMatrix.falseAllow || {}) },
+      falseBlock: { ...DEFAULT_LOSS_MATRIX.falseBlock, ...(raw.lossMatrix.falseBlock || {}) },
+    };
+  } catch {
+    return DEFAULT_LOSS_MATRIX;
+  }
+}
+
+/**
+ * Look up the maximum applicable cost for a side of the loss matrix.
+ * A single high-cost tag (e.g. `deploy-prod`) dominates — one dangerous tag
+ * in a bundle of otherwise innocuous tags must still flip the decision.
+ */
+function resolveCost(matrixSide, tags) {
+  const defaultCost = Number(matrixSide?.default ?? 1);
+  let cost = Number.isFinite(defaultCost) ? defaultCost : 1;
+  for (const tag of tags || []) {
+    const key = String(tag || '').trim().toLowerCase();
+    if (!key) continue;
+    const candidate = Number(matrixSide?.[key]);
+    if (Number.isFinite(candidate) && candidate > cost) cost = candidate;
+  }
+  return cost;
+}
+
+/**
+ * Clip a number to [min, max]. Used to bound the Bayes factor so a single
+ * noisy tag (e.g. 1/1 harmful) cannot flip the decision on the basis of one
+ * observation. The clip window is conservative on purpose.
+ */
+function clip(value, min, max) {
+  if (Number.isNaN(value) || value === undefined || value === null) return min;
+  // +Infinity/-Infinity are finite conceptually at the bounds — clamp them to
+  // the nearest edge rather than silently collapsing to `min`.
+  if (value === Infinity) return max;
+  if (value === -Infinity) return min;
+  if (typeof value !== 'number') return min;
+  return Math.min(Math.max(value, min), max);
+}
+
+/**
+ * Normalize a tag into the canonical lowercase key used by the model's
+ * pattern summary. Returns an empty string for falsy or non-string tags.
+ */
+function normalizeTag(tag) {
+  return String(tag || '').trim().toLowerCase();
+}
+
+/**
+ * Build a Map(tag -> riskRate) from the model's `highRiskTags` array.
+ * `riskRate` is empirical P(harmful | tag) computed from feedback sequences
+ * by `risk-scorer.buildPatternSummary`.
+ */
+function buildRiskRateMap(highRiskTags) {
+  const map = new Map();
+  if (!Array.isArray(highRiskTags)) return map;
+  for (const bucket of highRiskTags) {
+    const key = normalizeTag(bucket?.key || bucket?.tag);
+    if (!key) continue;
+    const rate = Number(bucket?.riskRate ?? bucket?.rate);
+    if (Number.isFinite(rate) && rate >= 0 && rate <= 1) {
+      map.set(key, rate);
+    }
+  }
+  return map;
+}
+
+/**
+ * Compute P(harmful | tags) as a Bayes-factor update over a starting
+ * probability. If `modelProbability` is supplied (the trained scorer's
+ * direct output), it seeds the update — richer feature evidence than the
+ * raw base rate. Otherwise we fall back to the prior.
+ *
+ * For each observed tag with a known empirical risk rate, we multiply the
+ * current odds by `riskRate / prior` (the Bayes factor), then convert odds
+ * back to probability. The Bayes factor is clipped to [0.25, 4.0] to keep a
+ * single sparsely-observed tag from dominating.
+ */
+function computeBayesPosterior({ tags, riskByTag, baseRate, modelProbability } = {}) {
+  const prior = clip(Number(baseRate) || 0, 0.01, 0.99);
+  const seed = Number.isFinite(modelProbability) ? clip(modelProbability, 0.01, 0.99) : prior;
+
+  let odds = seed / (1 - seed);
+  const rateMap = riskByTag instanceof Map
+    ? riskByTag
+    : new Map(Object.entries(riskByTag || {}).map(([k, v]) => [normalizeTag(k), Number(v)]));
+
+  const evidence = [];
+  for (const tag of tags || []) {
+    const key = normalizeTag(tag);
+    if (!key) continue;
+    const rate = rateMap.get(key);
+    if (!Number.isFinite(rate)) continue;
+    const bayesFactor = clip(rate / prior, 0.25, 4.0);
+    odds *= bayesFactor;
+    evidence.push({ tag: key, rate, bayesFactor: round3(bayesFactor) });
+  }
+
+  const pHarmful = odds / (1 + odds);
+  return {
+    pHarmful: round3(pHarmful),
+    pSafe: round3(1 - pHarmful),
+    prior: round3(prior),
+    seed: round3(seed),
+    evidence,
+  };
+}
+
+/**
+ * Cost-weighted Bayes-optimal decision. Block iff
+ *   E[loss | allow] = P(harmful) * cost(falseAllow)
+ * exceeds
+ *   E[loss | block] = P(safe)    * cost(falseBlock).
+ *
+ * This reduces to the usual Bayes classifier when both costs are equal.
+ */
+function bayesOptimalDecision(posterior, tags, lossMatrix = DEFAULT_LOSS_MATRIX) {
+  const pHarmful = clip(Number(posterior?.pHarmful), 0, 1);
+  const pSafe = clip(Number(posterior?.pSafe ?? 1 - pHarmful), 0, 1);
+  const cFalseAllow = resolveCost(lossMatrix?.falseAllow || {}, tags);
+  const cFalseBlock = resolveCost(lossMatrix?.falseBlock || {}, tags);
+  const lossAllow = pHarmful * cFalseAllow;
+  const lossBlock = pSafe * cFalseBlock;
+  return {
+    decision: lossAllow > lossBlock ? 'block' : 'allow',
+    expectedLoss: {
+      allow: round3(lossAllow),
+      block: round3(lossBlock),
+    },
+    costs: { falseAllow: cFalseAllow, falseBlock: cFalseBlock },
+  };
+}
+
+/**
+ * Bayes error rate: the irreducible error floor of a classifier built on
+ * the current feature set, estimated empirically from `rows`.
+ *
+ * For each tag signature s we have n_s rows of which k_s were harmful. The
+ * optimal per-signature prediction errs with probability min(k/n, 1-k/n).
+ * Weighting by P(s) = n_s / N and summing gives the Bayes error rate.
+ *
+ * Returns null when `rows` is empty or not an array.
+ */
+function computeBayesErrorRate(rows) {
+  if (!Array.isArray(rows) || rows.length === 0) return null;
+
+  const buckets = new Map();
+  for (const row of rows) {
+    const sig = tagSignature(row);
+    if (!buckets.has(sig)) buckets.set(sig, { total: 0, harmful: 0 });
+    const bucket = buckets.get(sig);
+    bucket.total += 1;
+    if (isHarmful(row)) bucket.harmful += 1;
+  }
+
+  const total = rows.length;
+  let err = 0;
+  for (const { total: n, harmful: k } of buckets.values()) {
+    const p = n === 0 ? 0 : k / n;
+    err += (n / total) * Math.min(p, 1 - p);
+  }
+  return round3(err);
+}
+
+function tagSignature(row) {
+  const raw = Array.isArray(row?.targetTags)
+    ? row.targetTags
+    : Array.isArray(row?.tags)
+      ? row.tags
+      : [];
+  const normalized = raw.map(normalizeTag).filter(Boolean).sort();
+  return normalized.join('|') || '__none__';
+}
+
+/**
+ * Mirror of `risk-scorer.deriveTargetRisk` so this module has no cycle back
+ * into risk-scorer. Kept intentionally narrow — if risk-scorer's definition
+ * broadens, revisit here too.
+ */
+function isHarmful(row) {
+  if (!row || typeof row !== 'object') return false;
+  if (typeof row.targetRisk === 'number') return row.targetRisk > 0;
+  if (typeof row.accepted === 'boolean' && row.accepted === false) return true;
+  const label = String(row.label || row.signal || '').toLowerCase();
+  return label === 'negative';
+}
+
+function round3(n) {
+  if (!Number.isFinite(n)) return 0;
+  return Math.round(n * 1000) / 1000;
+}
+
+module.exports = {
+  DEFAULT_LOSS_MATRIX,
+  ENFORCEMENT_CONFIG_PATH,
+  loadLossMatrix,
+  resolveCost,
+  buildRiskRateMap,
+  computeBayesPosterior,
+  bayesOptimalDecision,
+  computeBayesErrorRate,
+  tagSignature,
+  isHarmful,
+  clip,
+  normalizeTag,
+};

package/scripts/gate-stats.js

@@ -4,6 +4,8 @@
 const fs = require('fs');
 const path = require('path');
 const { getAutoGatesPath } = require('./auto-promote-gates');
+const { computeBayesErrorRate } = require('./bayes-optimal-gate');
+const { sequencePathFor } = require('./risk-scorer');
 
 const PROJECT_ROOT = path.join(__dirname, '..');
 const MANUAL_GATES_PATH = path.join(PROJECT_ROOT, 'config', 'gates', 'default.json');
@@ -55,6 +57,14 @@ function calculateStats() {
   const estimatedMinutesSaved = (totalBlocked + totalWarned) * 15;
   const estimatedHoursSaved = (estimatedMinutesSaved / 60).toFixed(1);
 
+  // Bayes error rate: irreducible error floor of the current scorer given its
+  // feature set (tag signatures). If this is near zero, the scorer is already
+  // close to optimal — threshold tuning won't help, and new features are the
+  // only lever. If this is high, the feature set can't discriminate the signal
+  // and we should add features (file path, recency, commit context) rather
+  // than tune thresholds. Null when no feedback sequences have been recorded.
+  const bayesErrorRate = tryComputeBayesErrorRate();
+
   return {
     totalGates: allGates.length,
     manualGates: manualGates.length,
@@ -66,10 +76,26 @@ function calculateStats() {
     topBlocked,
     lastPromotion,
     estimatedHoursSaved,
+    bayesErrorRate,
     gates: allGates,
   };
 }
 
+function tryComputeBayesErrorRate() {
+  try {
+    const seqPath = sequencePathFor();
+    if (!fs.existsSync(seqPath)) return null;
+    const rows = fs.readFileSync(seqPath, 'utf8')
+      .split('\n')
+      .filter(Boolean)
+      .map((line) => { try { return JSON.parse(line); } catch { return null; } })
+      .filter(Boolean);
+    return computeBayesErrorRate(rows);
+  } catch {
+    return null;
+  }
+}
+
 function formatLastPromotion(promo) {
   if (!promo) return 'none';
   const ts = promo.timestamp ? new Date(promo.timestamp) : null;
@@ -94,9 +120,18 @@ function formatStats(stats) {
   lines.push(`  Top blocked gate: ${stats.topBlocked ? `${stats.topBlocked.id} (${stats.topBlocked.occurrences || 0} blocks)` : 'none'}`);
   lines.push(`  Last promotion: ${formatLastPromotion(stats.lastPromotion)}`);
   lines.push(`  Estimated time saved: ~${stats.estimatedHoursSaved} hours`);
+  lines.push(`  Bayes error rate: ${formatBayesErrorRate(stats.bayesErrorRate)}`);
   return lines.join('\n');
 }
 
+function formatBayesErrorRate(rate) {
+  if (rate === null || rate === undefined) return 'n/a (no feedback sequences yet)';
+  const pct = (rate * 100).toFixed(1);
+  if (rate < 0.02) return `${pct}% — scorer is near-optimal; add features, don't tune thresholds`;
+  if (rate < 0.10) return `${pct}% — scorer has modest headroom`;
+  return `${pct}% — high irreducible error; the feature set can't discriminate`;
+}
+
 if (require.main === module) {
   try {
     const stats = calculateStats();
@@ -111,6 +146,8 @@ module.exports = {
   calculateStats,
   formatStats,
   formatLastPromotion,
+  formatBayesErrorRate,
   loadGatesFile,
+  tryComputeBayesErrorRate,
   MANUAL_GATES_PATH,
 };

package/scripts/mailer/resend-mailer.js

@@ -36,7 +36,12 @@ const SENDER_DNS_CACHE_MS = 10 * 60 * 1000;
 const ANGLE_EMAIL_RE = /<([^<>@\s]{1,64}@[^<>@\s]{1,255})>/;
 const BARE_EMAIL_RE = /([^\s<>@]{1,64}@[^\s<>@]{1,255})/;
 const DKIM_PUBLIC_KEY_RE = /^p=/i;
-const AMAZON_SES_MX_RE = /feedback-smtp\..*amazonaws\.com\.?$/i;
+// Resend fronts outbound mail with Amazon SES; the MX for send.<domain> points
+// at feedback-smtp.<region>.amazonses.com. Earlier revisions of this regex
+// mistakenly matched `amazonaws.com`, so the positive branch never fired in
+// production. Matching `amazonses.com` (optionally with a trailing dot) is
+// what Resend's DNS setup wizard actually publishes.
+const AMAZON_SES_MX_RE = /feedback-smtp\..*amazonses\.com\.?$/i;
 const AMAZON_SES_SPF_RE = /include:amazonses\.com/i;
 const TRAILING_EMAIL_DOMAIN_PUNCTUATION = new Set(['>', ')', ',', '.', ';']);
 const senderDnsCache = new Map();
@@ -504,6 +509,11 @@ module.exports = {
   renderTrialWelcomeBodies,
   _resolveSenderAddress: resolveSenderAddress,
   _hasResendSenderDns: hasResendSenderDns,
+  _recordsHaveResendDns: recordsHaveResendDns,
+  _getCachedSenderDnsReadiness: getCachedSenderDnsReadiness,
+  _setCachedSenderDnsReadiness: setCachedSenderDnsReadiness,
+  _senderDnsCache: senderDnsCache,
+  _SENDER_DNS_CACHE_MS: SENDER_DNS_CACHE_MS,
   _constants: {
     PRODUCT_NAME,
     DASHBOARD_URL,