thumbgate 0.9.9

package/scripts/prove-predictive-insights.js

@@ -0,0 +1,357 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const ROOT = path.join(__dirname, '..');
+
+function resolveProofPaths() {
+  const proofDir = process.env.THUMBGATE_PROOF_DIR || path.join(ROOT, 'proof');
+  return {
+    proofDir,
+    reportJson: path.join(proofDir, 'predictive-insights-report.json'),
+    reportMd: path.join(proofDir, 'predictive-insights-report.md'),
+  };
+}
+
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function buildStubTelemetry() {
+  return {
+    window: {
+      window: '30d',
+      timeZone: 'America/New_York',
+      bounded: true,
+      startLocalDate: '2026-03-01',
+      endLocalDate: '2026-03-30',
+      now: '2026-03-30T12:00:00.000Z',
+    },
+    latestSeenAt: '2026-03-30T12:00:00.000Z',
+    visitors: {
+      uniqueVisitors: 18,
+      attributionCoverageRate: 1,
+      byCreator: { reach_vb: 10, buildwithai: 8 },
+      bySource: { producthunt: 11, youtube: 7 },
+      byTrafficChannel: { producthunt: 11, youtube: 7 },
+    },
+    ctas: {
+      checkoutStarts: 4,
+      byCreator: { reach_vb: 3, buildwithai: 1 },
+      bySource: { producthunt: 3, youtube: 1 },
+      byTrafficChannel: { producthunt: 3, youtube: 1 },
+      checkoutStartsByCreator: { reach_vb: 3, buildwithai: 1 },
+      checkoutStartsBySource: { producthunt: 3, youtube: 1 },
+      checkoutStartsByTrafficChannel: { producthunt: 3, youtube: 1 },
+    },
+    buyerLoss: {
+      totalSignals: 2,
+      reasonsByCode: { too_expensive: 1 },
+    },
+    pricing: {
+      pricingInterestEvents: 5,
+    },
+  };
+}
+
+function buildStubBilling() {
+  return {
+    signups: {
+      uniqueLeads: 2,
+    },
+    revenue: {
+      paidCustomers: 1,
+      bookedRevenueCents: 1900,
+    },
+    pipeline: {
+      workflowSprintLeads: { total: 2, byCreator: { reach_vb: 1, buildwithai: 1 } },
+      qualifiedWorkflowSprintLeads: { total: 1, byCreator: { reach_vb: 1 } },
+    },
+    attribution: {
+      acquisitionByCreator: { reach_vb: 1, buildwithai: 1 },
+      acquisitionBySource: { producthunt: 1, youtube: 1 },
+      paidByCreator: { reach_vb: 1 },
+      paidBySource: { producthunt: 1 },
+      bookedRevenueByCreatorCents: { reach_vb: 1900 },
+      bookedRevenueBySourceCents: { producthunt: 1900 },
+    },
+    dataQuality: {
+      unreconciledPaidEvents: 0,
+    },
+    keys: {
+      active: 2,
+      totalUsage: 180,
+    },
+  };
+}
+
+function buildStubStaging() {
+  return {
+    sourceHashes: {
+      telemetry: 'predictive-proof-telemetry',
+      billing: 'predictive-proof-billing',
+    },
+    dims: {
+      creators: [
+        {
+          key: 'reach_vb',
+          pageViews: 10,
+          checkoutStarts: 3,
+          acquisitionLeads: 1,
+          paidCustomers: 1,
+          bookedRevenueCents: 1900,
+          workflowSprintLeads: 1,
+          qualifiedWorkflowSprintLeads: 1,
+        },
+        {
+          key: 'buildwithai',
+          pageViews: 8,
+          checkoutStarts: 1,
+          acquisitionLeads: 1,
+          paidCustomers: 0,
+          bookedRevenueCents: 0,
+          workflowSprintLeads: 1,
+          qualifiedWorkflowSprintLeads: 0,
+        },
+      ],
+      sources: [
+        {
+          key: 'producthunt',
+          pageViews: 11,
+          checkoutStarts: 3,
+          acquisitionLeads: 1,
+          paidCustomers: 1,
+          bookedRevenueCents: 1900,
+        },
+        {
+          key: 'youtube',
+          pageViews: 7,
+          checkoutStarts: 1,
+          acquisitionLeads: 1,
+          paidCustomers: 0,
+          bookedRevenueCents: 0,
+        },
+      ],
+    },
+    facts: {
+      funnel: [{ key: 'predictive-proof-funnel' }],
+      revenue: [{ key: 'predictive-proof-revenue' }],
+      quality: [{ key: 'predictive-proof-quality' }],
+    },
+    reconciliation: {
+      status: 'healthy',
+      warningCount: 0,
+      warnings: [],
+    },
+  };
+}
+
+async function run() {
+  const { proofDir, reportJson, reportMd } = resolveProofPaths();
+  const {
+    buildBenchmarks,
+    buildPredictiveInsights,
+    detectPredictiveAnomalies,
+    scoreDimensionForecasts,
+    scoreUpgradePropensity,
+  } = require('./predictive-insights');
+  const { formatReport } = require('./analytics-report');
+  const { buildSemanticSnapshot } = require('./agentic-data-pipeline');
+  const { buildVerifyPlan, recordVerifyWorkflowRun } = require('./verify-run');
+
+  const telemetryAnalytics = buildStubTelemetry();
+  const billingSummary = buildStubBilling();
+  const stagingModel = buildStubStaging();
+  const gateStats = { blocked: 12 };
+  const team = { activeAgents: 4 };
+  const results = { passed: 0, failed: 0, requirements: {} };
+
+  const checks = [
+    {
+      id: 'PREDICT-01',
+      desc: 'benchmarks derive funnel priors from telemetry, billing, and staged dimensions',
+      fn: () => {
+        const benchmarks = buildBenchmarks({ telemetryAnalytics, billingSummary, stagingModel });
+        if (benchmarks.uniqueVisitors !== 18 || benchmarks.checkoutStarts !== 4) {
+          throw new Error('Expected funnel priors for visitors and checkout starts');
+        }
+        if (benchmarks.revenuePerPaidCents !== 1900) {
+          throw new Error('Expected revenue per paid customer prior');
+        }
+      },
+    },
+    {
+      id: 'PREDICT-02',
+      desc: 'upgrade propensity scores surface ranked Pro and Team drivers',
+      fn: () => {
+        const propensity = scoreUpgradePropensity({
+          telemetryAnalytics,
+          billingSummary,
+          stagingModel,
+          gateStats,
+          team,
+        });
+        if (propensity.pro.band === 'very_low') {
+          throw new Error('Expected non-trivial Pro propensity');
+        }
+        if (!propensity.team.drivers.length) {
+          throw new Error('Expected ranked Team drivers');
+        }
+      },
+    },
+    {
+      id: 'PREDICT-03',
+      desc: 'dimension forecasts rank creator and source revenue opportunities',
+      fn: () => {
+        const benchmarks = buildBenchmarks({ telemetryAnalytics, billingSummary, stagingModel });
+        const creatorForecasts = scoreDimensionForecasts(stagingModel.dims.creators, benchmarks, 'key');
+        if (creatorForecasts[0].key !== 'buildwithai') {
+          throw new Error('Expected creator opportunity ranking to favor under-monetized creator');
+        }
+        if (creatorForecasts[0].opportunityRevenueCents <= 0) {
+          throw new Error('Expected incremental creator opportunity');
+        }
+      },
+    },
+    {
+      id: 'PREDICT-04',
+      desc: 'anomaly detection flags pricing resistance and channel underperformance',
+      fn: () => {
+        const benchmarks = buildBenchmarks({ telemetryAnalytics, billingSummary, stagingModel });
+        const anomalies = detectPredictiveAnomalies({
+          telemetryAnalytics: {
+            ...telemetryAnalytics,
+            buyerLoss: { totalSignals: 3, reasonsByCode: { too_expensive: 2 } },
+          },
+          billingSummary,
+          creatorForecasts: scoreDimensionForecasts(stagingModel.dims.creators, benchmarks, 'key'),
+          sourceForecasts: scoreDimensionForecasts(stagingModel.dims.sources, benchmarks, 'key'),
+        });
+        if (!anomalies.some((entry) => entry.type === 'pricing_resistance')) {
+          throw new Error('Expected pricing resistance anomaly');
+        }
+      },
+    },
+    {
+      id: 'PREDICT-05',
+      desc: 'dashboard, report, and semantic snapshot expose predictive insights without manual joins',
+      fn: () => {
+        const predictive = buildPredictiveInsights({
+          telemetryAnalytics,
+          billingSummary,
+          stagingModel,
+          gateStats,
+          team,
+        });
+        const report = formatReport(
+          { downloads: [{ day: '2026-03-24', downloads: 42 }] },
+          { downloads: 42 },
+          { stargazers_count: 5, forks_count: 1, open_issues_count: 0, subscribers_count: 1 },
+          { time: { created: '2026-03-01T00:00:00.000Z', modified: '2026-03-24T00:00:00.000Z' } },
+          telemetryAnalytics,
+          billingSummary,
+        );
+        const semanticSnapshot = buildSemanticSnapshot({
+          window: telemetryAnalytics.window,
+          snapshotId: 'predictive-proof',
+          telemetryAnalytics,
+          billingSummary,
+          stagingModel,
+          gateStats,
+          team,
+        });
+
+        if (!report.includes('Predictive Insights')) {
+          throw new Error('Expected analytics report predictive section');
+        }
+        if (semanticSnapshot.metrics.predictedBookedRevenueCents !== predictive.revenueForecast.predictedBookedRevenueCents) {
+          throw new Error('Expected semantic snapshot predictive revenue metric');
+        }
+      },
+    },
+    {
+      id: 'PREDICT-06',
+      desc: 'verify:full includes the predictive proof lane and records its artifact',
+      fn: () => {
+        const commands = buildVerifyPlan('full')
+          .map((step) => [step.command, ...(step.args || [])].join(' '))
+          .join('\n');
+        if (!commands.includes('prove:predictive-insights')) {
+          throw new Error('Expected verify:full to include prove:predictive-insights');
+        }
+
+        const feedbackDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rlhf-predictive-proof-'));
+        const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'rlhf-predictive-proof-cwd-'));
+        try {
+          const entry = recordVerifyWorkflowRun('full', cwd, feedbackDir);
+          if (!entry.proofArtifacts.some((artifact) => artifact.endsWith(path.join('proof', 'predictive-insights-report.json')))) {
+            throw new Error('Expected workflow run predictive artifact');
+          }
+        } finally {
+          fs.rmSync(feedbackDir, { recursive: true, force: true });
+          fs.rmSync(cwd, { recursive: true, force: true });
+        }
+      },
+    },
+  ];
+
+  console.log('Predictive Insights - Proof Gate\n');
+  console.log('Checking requirements:\n');
+
+  for (const check of checks) {
+    try {
+      await check.fn();
+      results.passed += 1;
+      results.requirements[check.id] = { desc: check.desc, status: 'passed' };
+      console.log(`✅ ${check.id} — ${check.desc}`);
+    } catch (error) {
+      results.failed += 1;
+      results.requirements[check.id] = {
+        desc: check.desc,
+        status: 'failed',
+        error: error.message,
+      };
+      console.log(`❌ ${check.id} — ${check.desc}`);
+      console.log(`   ${error.message}`);
+    }
+  }
+
+  ensureDir(proofDir);
+  const report = {
+    phase: '16-predictive-insights',
+    generatedAt: new Date().toISOString(),
+    passed: results.passed,
+    failed: results.failed,
+    requirements: results.requirements,
+  };
+  fs.writeFileSync(reportJson, `${JSON.stringify(report, null, 2)}\n`, 'utf8');
+
+  const markdown = [
+    '# Predictive Insights Proof Report',
+    '',
+    `- passed: ${results.passed}`,
+    `- failed: ${results.failed}`,
+    '',
+    ...Object.entries(results.requirements).map(([id, entry]) => {
+      const prefix = entry.status === 'passed' ? '[x]' : '[ ]';
+      const suffix = entry.error ? ` — ${entry.error}` : '';
+      return `${prefix} **${id}** ${entry.desc}${suffix}`;
+    }),
+    '',
+    `${results.passed} passed, ${results.failed} failed`,
+  ].join('\n');
+  fs.writeFileSync(reportMd, `${markdown}\n`, 'utf8');
+
+  console.log(`\n${results.passed} passed, ${results.failed} failed`);
+  if (results.failed > 0) {
+    process.exitCode = 1;
+  }
+}
+
+run().catch((error) => {
+  console.error(error.message);
+  process.exit(1);
+});

package/scripts/prove-runtime.js

@@ -0,0 +1,350 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const { buildManagedScheduleCommand } = require('./schedule-manager');
+
+const ROOT = path.join(__dirname, '..');
+const RUNNER_PATH = require.resolve('./async-job-runner');
+const FEEDBACK_PATH = require.resolve('./feedback-loop');
+const VERIFICATION_PATH = require.resolve('./verification-loop');
+const EXPERIMENT_TRACKER_PATH = require.resolve('./experiment-tracker');
+const VERIFY_RUN_PATH = require.resolve('./verify-run');
+
+function resolveProofPaths() {
+  const proofDir = process.env.THUMBGATE_RUNTIME_PROOF_DIR || process.env.THUMBGATE_PROOF_DIR || path.join(ROOT, 'proof');
+  return {
+    proofDir,
+    reportJson: path.join(proofDir, 'runtime-report.json'),
+    reportMd: path.join(proofDir, 'runtime-report.md'),
+  };
+}
+
+function resetModules() {
+  [
+    RUNNER_PATH,
+    FEEDBACK_PATH,
+    VERIFICATION_PATH,
+    EXPERIMENT_TRACKER_PATH,
+    VERIFY_RUN_PATH,
+  ].forEach((modulePath) => {
+    delete require.cache[modulePath];
+  });
+}
+
+function stubModule(modulePath, exports) {
+  require.cache[modulePath] = {
+    id: modulePath,
+    filename: modulePath,
+    loaded: true,
+    exports,
+  };
+}
+
+function makeAcceptedVerification() {
+  return {
+    accepted: true,
+    attempts: 1,
+    finalVerification: {
+      score: 1,
+      violations: [],
+    },
+    partnerStrategy: {
+      profile: 'strict_reviewer',
+      verificationMode: 'evidence_first',
+    },
+    partnerReward: {
+      reward: 1,
+    },
+  };
+}
+
+function makeRejectedVerification() {
+  return {
+    accepted: false,
+    attempts: 2,
+    finalVerification: {
+      score: 0.2,
+      violations: [
+        {
+          pattern: 'webhook signature mismatch',
+          avoidRule: 'Verify webhook signatures before deploy.',
+        },
+      ],
+    },
+    partnerStrategy: {
+      profile: 'strict_reviewer',
+      verificationMode: 'evidence_first',
+    },
+    partnerReward: {
+      reward: 0,
+    },
+  };
+}
+
+function loadRuntimeHarness(feedbackDir, verificationLoopImpl) {
+  process.env.THUMBGATE_FEEDBACK_DIR = feedbackDir;
+  resetModules();
+  stubModule(VERIFICATION_PATH, {
+    runVerificationLoop: verificationLoopImpl,
+  });
+
+  return {
+    runner: require('./async-job-runner'),
+    experimentTracker: require('./experiment-tracker'),
+  };
+}
+
+function cleanupHarness(feedbackDir) {
+  resetModules();
+  delete process.env.THUMBGATE_FEEDBACK_DIR;
+  fs.rmSync(feedbackDir, { recursive: true, force: true });
+}
+
+async function run() {
+  const results = { passed: 0, failed: 0, requirements: {} };
+  const { proofDir, reportJson, reportMd } = resolveProofPaths();
+
+  const checks = [
+    {
+      id: 'RUNTIME-01',
+      desc: 'stage execution persists checkpointed state and stage history',
+      fn: () => {
+        const feedbackDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rlhf-runtime-proof-'));
+        try {
+          const { runner } = loadRuntimeHarness(feedbackDir, () => makeAcceptedVerification());
+          runner.executeJob({
+            id: 'checkpoint-job',
+            tags: ['runtime'],
+            stages: [
+              { name: 'draft', context: 'draft ready' },
+              { name: 'ship', appendContext: 'ship ready' },
+            ],
+          });
+          const state = runner.readJobState('checkpoint-job');
+          if (state.status !== 'completed') throw new Error(`Expected completed state, got ${state.status}`);
+          if (state.stageHistory.length !== 2) throw new Error('Expected 2 completed stages');
+          if (state.checkpoints.length !== 2) throw new Error('Expected 2 checkpoints');
+          if (state.currentContext !== 'draft ready\nship ready') {
+            throw new Error(`Unexpected final context: ${state.currentContext}`);
+          }
+        } finally {
+          cleanupHarness(feedbackDir);
+        }
+      },
+    },
+    {
+      id: 'RUNTIME-02',
+      desc: 'pause requests yield a paused checkpoint and resume continues from the next stage',
+      fn: () => {
+        const feedbackDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rlhf-runtime-proof-'));
+        try {
+          const { runner } = loadRuntimeHarness(feedbackDir, () => makeAcceptedVerification());
+          const job = {
+            id: 'pause-job',
+            tags: ['runtime'],
+            stages: [
+              {
+                name: 'draft',
+                run({ controller }) {
+                  controller.requestPause({ reason: 'proof pause' });
+                  return { context: 'draft ready' };
+                },
+              },
+              {
+                name: 'ship',
+                run() {
+                  return { appendContext: 'ship ready' };
+                },
+              },
+            ],
+          };
+
+          const paused = runner.executeJob(job);
+          const pausedState = runner.readJobState('pause-job');
+          const resumed = runner.resumeJob('pause-job', job);
+
+          if (paused.status !== 'paused') throw new Error(`Expected paused result, got ${paused.status}`);
+          if (pausedState.nextStageIndex !== 1) throw new Error(`Expected nextStageIndex=1, got ${pausedState.nextStageIndex}`);
+          if (resumed.status !== 'completed') throw new Error(`Expected resumed completion, got ${resumed.status}`);
+        } finally {
+          cleanupHarness(feedbackDir);
+        }
+      },
+    },
+    {
+      id: 'RUNTIME-03',
+      desc: 'managed job files auto-resume through resumeManagedJobs without manual stage reconstruction',
+      fn: () => {
+        const feedbackDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rlhf-runtime-proof-'));
+        try {
+          const { runner } = loadRuntimeHarness(feedbackDir, () => makeAcceptedVerification());
+          const jobFile = path.join(feedbackDir, 'managed-job.json');
+          fs.writeFileSync(jobFile, JSON.stringify({
+            id: 'managed-job',
+            tags: ['runtime'],
+            stages: [
+              { name: 'plan', context: 'plan ready' },
+              { name: 'ship', appendContext: 'ship ready' },
+            ],
+          }, null, 2));
+
+          runner.requestJobControl('managed-job', 'pause', { reason: 'pause before start' });
+          const paused = runner.runJobFromFile(jobFile);
+          const resumed = runner.resumeManagedJobs();
+          const state = runner.readJobState('managed-job');
+
+          if (paused.status !== 'paused') throw new Error(`Expected paused managed job, got ${paused.status}`);
+          if (resumed.completed !== 1) throw new Error(`Expected 1 resumed completion, got ${resumed.completed}`);
+          if (state.currentContext !== 'plan ready\nship ready') {
+            throw new Error(`Unexpected managed final context: ${state.currentContext}`);
+          }
+        } finally {
+          cleanupHarness(feedbackDir);
+        }
+      },
+    },
+    {
+      id: 'RUNTIME-04',
+      desc: 'failed verification queues an auto-improvement experiment',
+      fn: () => {
+        const feedbackDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rlhf-runtime-proof-'));
+        try {
+          const { runner, experimentTracker } = loadRuntimeHarness(feedbackDir, () => makeRejectedVerification());
+          const result = runner.executeJob({
+            id: 'verification-fail-job',
+            context: 'webhook signature mismatch',
+            tags: ['billing'],
+            skill: 'billing-guard',
+          });
+          const experiments = experimentTracker.loadExperiments();
+          const experiment = experiments[0];
+
+          if (result.status !== 'failed') throw new Error(`Expected failed result, got ${result.status}`);
+          if (!experiment) throw new Error('Expected one pending improvement experiment');
+          if (experiment.mutation.failureType !== 'verification') {
+            throw new Error(`Expected verification failureType, got ${experiment.mutation.failureType}`);
+          }
+        } finally {
+          cleanupHarness(feedbackDir);
+        }
+      },
+    },
+    {
+      id: 'RUNTIME-05',
+      desc: 'schedule manager builds a managed async-job-runner command for job files',
+      fn: () => {
+        const command = buildManagedScheduleCommand({
+          jobFile: '/tmp/thumbgate/jobs/runtime-proof.json',
+          autoResume: true,
+        });
+
+        if (!command.includes('async-job-runner.js')) throw new Error('Missing async-job-runner reference');
+        if (!command.includes('runJobFromFile')) throw new Error('Missing runJobFromFile invocation');
+        if (!command.includes('runtime-proof.json')) throw new Error('Missing job file reference');
+      },
+    },
+    {
+      id: 'RUNTIME-06',
+      desc: 'verify-run full includes the runtime proof lane and artifact',
+      fn: () => {
+        const feedbackDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rlhf-runtime-proof-'));
+        const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'rlhf-runtime-proof-cwd-'));
+        try {
+          process.env.THUMBGATE_FEEDBACK_DIR = feedbackDir;
+          resetModules();
+          const { buildVerifyPlan, recordVerifyWorkflowRun } = require('./verify-run');
+          const plan = buildVerifyPlan('full');
+          const commands = plan.map((step) => [step.command, ...(step.args || [])].join(' ')).join('\n');
+          if (!commands.includes('prove:runtime')) {
+            throw new Error('verify:full is missing prove:runtime');
+          }
+
+          const entry = recordVerifyWorkflowRun('full', cwd, feedbackDir);
+          const hasRuntimeArtifact = entry.proofArtifacts.some((artifact) => artifact.endsWith(path.join('proof', 'runtime-report.json')));
+          if (!hasRuntimeArtifact) {
+            throw new Error('verify workflow run is missing runtime proof artifact');
+          }
+        } finally {
+          resetModules();
+          delete process.env.THUMBGATE_FEEDBACK_DIR;
+          fs.rmSync(feedbackDir, { recursive: true, force: true });
+          fs.rmSync(cwd, { recursive: true, force: true });
+        }
+      },
+    },
+  ];
+
+  console.log('Interruptible Runtime - Proof Gate\n');
+  console.log('Checking requirements:\n');
+
+  for (const check of checks) {
+    try {
+      await check.fn();
+      results.passed += 1;
+      results.requirements[check.id] = { status: 'pass', desc: check.desc };
+      console.log(`  PASS  ${check.id}: ${check.desc}`);
+    } catch (error) {
+      results.failed += 1;
+      results.requirements[check.id] = {
+        status: 'fail',
+        desc: check.desc,
+        error: error.message,
+      };
+      console.error(`  FAIL  ${check.id}: ${error.message}`);
+    }
+  }
+
+  fs.mkdirSync(proofDir, { recursive: true });
+
+  const report = {
+    phase: '12-interruptible-runtime',
+    generatedAt: new Date().toISOString(),
+    passed: results.passed,
+    failed: results.failed,
+    total: checks.length,
+    requirements: results.requirements,
+  };
+
+  fs.writeFileSync(reportJson, `${JSON.stringify(report, null, 2)}\n`);
+
+  const markdown = [
+    '# Interruptible Runtime Proof Report',
+    '',
+    `Generated: ${report.generatedAt}`,
+    `Result: ${results.passed}/${checks.length} passed`,
+    '',
+    '## Requirements',
+    '',
+    ...Object.entries(results.requirements).map(([id, requirement]) => {
+      const checkbox = requirement.status === 'pass' ? '[x]' : '[ ]';
+      const errorLine = requirement.error ? `\n  - Error: \`${requirement.error}\`` : '';
+      return `- ${checkbox} **${id}**: ${requirement.desc}${errorLine}`;
+    }),
+    '',
+    `${results.passed} passed, ${results.failed} failed`,
+    '',
+  ].join('\n');
+  fs.writeFileSync(reportMd, `${markdown}\n`);
+
+  console.log(`\nResult: ${results.passed} passed, ${results.failed} failed`);
+  console.log(`Report: ${reportJson}`);
+
+  if (results.failed > 0) {
+    process.exitCode = 1;
+  }
+}
+
+if (require.main === module) {
+  run().catch((error) => {
+    console.error(error.message || String(error));
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  resolveProofPaths,
+  run,
+};