thumbgate 1.4.2 → 1.4.4

package/scripts/prove-packaged-runtime.js

@@ -1,326 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const http = require('http');
-const net = require('net');
-const { execFileSync } = require('child_process');
-
-const ROOT = path.join(__dirname, '..');
-const DEFAULT_TIMEOUT_MS = 15000;
-const DEFAULT_PUBLISH_INSTALL_RETRIES = 6;
-const DEFAULT_PUBLISH_INSTALL_DELAY_MS = 5000;
-const MAX_PUBLISH_INSTALL_DELAY_MS = 30000;
-const STATUSLINE_INPUT = JSON.stringify({ context_window: { used_percentage: 12 } });
-
-function parseArgs(argv = process.argv.slice(2)) {
-  const parsed = {};
-  for (let index = 0; index < argv.length; index += 1) {
-    const token = argv[index];
-    if (!token.startsWith('--')) continue;
-    const [rawKey, inlineValue] = token.slice(2).split('=');
-    const key = rawKey.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
-    const value = inlineValue !== undefined ? inlineValue : argv[index + 1];
-    parsed[key] = value;
-    if (inlineValue === undefined) index += 1;
-  }
-  return parsed;
-}
-
-function pkgVersion() {
-  return require(path.join(ROOT, 'package.json')).version;
-}
-
-function packCurrentRepo(packDir) {
-  fs.mkdirSync(packDir, { recursive: true });
-  const output = execFileSync('npm', ['pack', '--json', '--pack-destination', packDir], {
-    cwd: ROOT,
-    encoding: 'utf8',
-    stdio: ['ignore', 'pipe', 'pipe'],
-  });
-  const parsed = JSON.parse(output);
-  const fileName = parsed && parsed[0] && parsed[0].filename;
-  if (!fileName) {
-    throw new Error('npm pack did not return a tarball filename');
-  }
-  return path.join(packDir, fileName);
-}
-
-function installPackage(prefixDir, packageSpec) {
-  fs.mkdirSync(prefixDir, { recursive: true });
-  execFileSync('npm', ['install', '--prefix', prefixDir, '--no-fund', '--no-audit', packageSpec], {
-    cwd: ROOT,
-    encoding: 'utf8',
-    stdio: ['ignore', 'pipe', 'pipe'],
-  });
-  return path.join(prefixDir, 'node_modules', '.bin', 'thumbgate');
-}
-
-function isRemotePackageSpec(packageSpec) {
-  if (!packageSpec) return false;
-  return !/^(?:\.{0,2}\/|\/|file:)/.test(packageSpec) && !packageSpec.endsWith('.tgz');
-}
-
-function isTransientRegistryMiss(error) {
-  const text = [
-    error && error.message,
-    error && error.stdout,
-    error && error.stderr,
-  ]
-    .filter(Boolean)
-    .join('\n');
-  return /ETARGET|No matching version found|npm error code E404|404 Not Found/i.test(text);
-}
-
-async function installPackageWithRetry(prefixDir, packageSpec, options = {}) {
-  const installImpl = options.installImpl || installPackage;
-  const sleepImpl = options.sleepImpl || sleep;
-  const remotePackage = options.remotePackage !== undefined ? options.remotePackage : isRemotePackageSpec(packageSpec);
-  const attempts = remotePackage ? Number(options.attempts || DEFAULT_PUBLISH_INSTALL_RETRIES) : 1;
-  let delayMs = Number(options.delayMs || DEFAULT_PUBLISH_INSTALL_DELAY_MS);
-  let lastError = null;
-
-  for (let attempt = 1; attempt <= attempts; attempt += 1) {
-    if (attempt > 1) {
-      fs.rmSync(prefixDir, { recursive: true, force: true });
-    }
-    try {
-      return installImpl(prefixDir, packageSpec);
-    } catch (error) {
-      lastError = error;
-      const retryable = remotePackage && isTransientRegistryMiss(error) && attempt < attempts;
-      if (!retryable) {
-        throw error;
-      }
-      process.stderr.write(
-        `Retrying published package install for ${packageSpec} after transient registry miss (${attempt}/${attempts - 1})\n`
-      );
-      await sleepImpl(delayMs);
-      delayMs = Math.min(Math.round(delayMs * 1.5), MAX_PUBLISH_INSTALL_DELAY_MS);
-    }
-  }
-
-  throw lastError || new Error(`Failed to install package ${packageSpec}`);
-}
-
-function request(url, timeoutMs = 2000) {
-  return new Promise((resolve, reject) => {
-    const req = http.get(url, (res) => {
-      let body = '';
-      res.setEncoding('utf8');
-      res.on('data', (chunk) => { body += chunk; });
-      res.on('end', () => resolve({ statusCode: res.statusCode, body }));
-    });
-    req.on('error', reject);
-    req.setTimeout(timeoutMs, () => {
-      req.destroy(new Error(`Timed out requesting ${url}`));
-    });
-  });
-}
-
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-function getAvailablePort() {
-  return new Promise((resolve, reject) => {
-    const server = net.createServer();
-    server.listen(0, '127.0.0.1', () => {
-      const address = server.address();
-      const port = address && address.port;
-      server.close((error) => {
-        if (error) {
-          reject(error);
-          return;
-        }
-        resolve(port);
-      });
-    });
-    server.on('error', reject);
-  });
-}
-
-async function waitForHealthy(origin, expectedVersion, timeoutMs = DEFAULT_TIMEOUT_MS) {
-  const startedAt = Date.now();
-  while (Date.now() - startedAt < timeoutMs) {
-    try {
-      const response = await request(`${origin}/health`);
-      if (response.statusCode === 200) {
-        const body = JSON.parse(response.body);
-        if (body.version === expectedVersion) {
-          return body;
-        }
-      }
-    } catch {
-      // Keep polling until the detached API server comes online.
-    }
-    await sleep(250);
-  }
-  throw new Error(`Timed out waiting for packaged runtime health at ${origin}`);
-}
-
-function renderStatusline(runtimeBin, projectDir, env) {
-  return execFileSync(runtimeBin, ['statusline-render'], {
-    cwd: projectDir,
-    env,
-    encoding: 'utf8',
-    input: STATUSLINE_INPUT,
-    stdio: ['pipe', 'pipe', 'pipe'],
-    timeout: 10000,
-  });
-}
-
-function runtimeStatePath(homeDir) {
-  return path.join(homeDir, '.thumbgate', 'runtime', 'statusline-api.json');
-}
-
-async function stopDetachedRuntime(homeDir) {
-  try {
-    const state = JSON.parse(fs.readFileSync(runtimeStatePath(homeDir), 'utf8'));
-    const pid = Number(state && state.pid);
-    if (!Number.isInteger(pid) || pid <= 0) return;
-    try {
-      process.kill(pid, 'SIGTERM');
-    } catch {
-      return;
-    }
-    for (let attempt = 0; attempt < 10; attempt += 1) {
-      await sleep(100);
-      try {
-        process.kill(pid, 0);
-      } catch {
-        return;
-      }
-    }
-    try {
-      process.kill(pid, 'SIGKILL');
-    } catch {
-      // Ignore cleanup races.
-    }
-  } catch {
-    // No runtime state means nothing to clean up.
-  }
-}
-
-async function runPackagedRuntimeSmoke(options = {}) {
-  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'thumbgate-packaged-runtime-'));
-  const homeDir = path.join(tempRoot, 'home');
-  const projectDir = path.join(tempRoot, 'project');
-  const packDir = path.join(tempRoot, 'pack');
-  const runtimeDir = path.join(tempRoot, 'runtime');
-  const expectedVersion = options.expectedVersion || pkgVersion();
-  const feedbackDir = path.join(projectDir, '.thumbgate');
-  fs.mkdirSync(homeDir, { recursive: true });
-  fs.mkdirSync(projectDir, { recursive: true });
-  fs.mkdirSync(feedbackDir, { recursive: true });
-  fs.writeFileSync(
-    path.join(feedbackDir, 'feedback-log.jsonl'),
-    [
-      JSON.stringify({ signal: 'positive', timestamp: '2026-04-08T20:00:00.000Z', context: 'packaged runtime smoke pass' }),
-      JSON.stringify({ signal: 'negative', timestamp: '2026-04-08T20:01:00.000Z', context: 'packaged runtime smoke fail path' }),
-    ].join('\n') + '\n'
-  );
-
-  try {
-    const packageSpec = options.packageSpec || packCurrentRepo(packDir);
-    const runtimeBin = await installPackageWithRetry(runtimeDir, packageSpec, {
-      attempts: options.installAttempts,
-      delayMs: options.installDelayMs,
-    });
-    if (!fs.existsSync(runtimeBin)) {
-      throw new Error(`Installed runtime binary is missing: ${runtimeBin}`);
-    }
-
-    const port = await getAvailablePort();
-    const origin = `http://127.0.0.1:${port}`;
-    const env = {
-      ...process.env,
-      HOME: homeDir,
-      THUMBGATE_PROJECT_DIR: projectDir,
-      THUMBGATE_LOCAL_API_ORIGIN: origin,
-      THUMBGATE_API_KEY: 'tg_packaged_runtime_smoke',
-      NO_COLOR: '1',
-    };
-
-    const initialStatusline = renderStatusline(runtimeBin, projectDir, env);
-    if (!initialStatusline.includes(`ThumbGate v${expectedVersion}`)) {
-      throw new Error(`Statusline version mismatch before boot: ${initialStatusline.trim()}`);
-    }
-    if (!/(Dashboard|Dashboard…)/.test(initialStatusline) || !/(Lessons|Lessons…)/.test(initialStatusline)) {
-      throw new Error(`Statusline missing dashboard affordances before boot: ${initialStatusline.trim()}`);
-    }
-
-    const health = await waitForHealthy(origin, expectedVersion, Number(options.timeoutMs || DEFAULT_TIMEOUT_MS));
-    const dashboard = await request(`${origin}/dashboard`);
-    const lessons = await request(`${origin}/lessons`);
-    if (dashboard.statusCode !== 200) {
-      throw new Error(`Packaged dashboard returned ${dashboard.statusCode}`);
-    }
-    if (lessons.statusCode !== 200) {
-      throw new Error(`Packaged lessons returned ${lessons.statusCode}`);
-    }
-
-    const readyStatusline = renderStatusline(runtimeBin, projectDir, env);
-    if (!/(Dashboard|Dashboard…)/.test(readyStatusline)) {
-      throw new Error(`Ready statusline missing dashboard label: ${readyStatusline.trim()}`);
-    }
-    if (!/(Lessons|Lessons…)/.test(readyStatusline)) {
-      throw new Error(`Ready statusline missing lessons label: ${readyStatusline.trim()}`);
-    }
-    if (readyStatusline.includes(`${origin}/dashboard`)) {
-      throw new Error(`Ready statusline leaked dashboard URL: ${readyStatusline.trim()}`);
-    }
-    if (readyStatusline.includes(`${origin}/lessons`)) {
-      throw new Error(`Ready statusline leaked lessons URL: ${readyStatusline.trim()}`);
-    }
-    // Thumbs-up/down icons stay inline while dashboard + lessons remain compact
-    // labels, even after the local API is up.
-    if (!readyStatusline.includes('👍')) {
-      throw new Error(`Ready statusline missing thumbs-up icon: ${readyStatusline.trim()}`);
-    }
-    if (!readyStatusline.includes('👎')) {
-      throw new Error(`Ready statusline missing thumbs-down icon: ${readyStatusline.trim()}`);
-    }
-
-    return {
-      packageSpec,
-      expectedVersion,
-      origin,
-      health,
-    };
-  } finally {
-    await stopDetachedRuntime(homeDir);
-    fs.rmSync(tempRoot, { recursive: true, force: true });
-  }
-}
-
-async function main() {
-  const args = parseArgs();
-  const result = await runPackagedRuntimeSmoke({
-    packageSpec: args.packageSpec,
-    expectedVersion: args.expectedVersion,
-    timeoutMs: args.timeoutMs,
-    installAttempts: args.installAttempts,
-    installDelayMs: args.installDelayMs,
-  });
-  process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
-}
-
-if (require.main === module) {
-  main().catch((error) => {
-    process.stderr.write(`${error.message || String(error)}\n`);
-    process.exit(1);
-  });
-}
-
-module.exports = {
-  getAvailablePort,
-  installPackageWithRetry,
-  isRemotePackageSpec,
-  isTransientRegistryMiss,
-  packCurrentRepo,
-  runPackagedRuntimeSmoke,
-  waitForHealthy,
-};

package/scripts/prove-predictive-insights.js

@@ -1,355 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const { ensureDir } = require('./fs-utils');
-
-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 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(), 'thumbgate-predictive-proof-'));
-        const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'thumbgate-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);
-});