thumbgate 1.4.2 → 1.4.4

package/scripts/prove-tessl.js

@@ -1,229 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-
-const {
-  exportTiles,
-  loadTileConfig,
-  verifyTiles,
-} = require('./tessl-export');
-
-const ROOT = path.join(__dirname, '..');
-
-function resolveProofPaths() {
-  const proofDir = process.env.THUMBGATE_PROOF_DIR || path.join(ROOT, 'proof');
-  return {
-    proofDir,
-    reportJson: path.join(proofDir, 'tessl-report.json'),
-    reportMd: path.join(proofDir, 'tessl-report.md'),
-  };
-}
-
-async function run() {
-  const { proofDir, reportJson, reportMd } = resolveProofPaths();
-  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'thumbgate-tessl-proof-'));
-  const results = { passed: 0, failed: 0, requirements: {} };
-
-  const checks = [
-    {
-      id: 'TESSL-01',
-      desc: 'tile config tracks only high-ROI first-party skills',
-      fn: () => {
-        const config = loadTileConfig();
-        const tileNames = config.tiles.map((tile) => tile.tileName);
-
-        if (config.defaultWorkspace !== 'thumbgate') {
-          throw new Error('Default Tessl workspace must stay thumbgate');
-        }
-        if (tileNames.length !== 2) {
-          throw new Error('Expected exactly two first-party Tessl tiles');
-        }
-        if (!tileNames.includes('agent-memory') || !tileNames.includes('thumbgate-feedback')) {
-          throw new Error('High-ROI ThumbGate tiles missing from config');
-        }
-      },
-    },
-    {
-      id: 'TESSL-02',
-      desc: 'export writes tile.json, index.md, and copied skills for every configured tile',
-      fn: () => {
-        const exported = exportTiles({ outDir: tempDir });
-
-        if (exported.length !== 2) {
-          throw new Error('Expected two exported Tessl tiles');
-        }
-
-        for (const tile of exported) {
-          for (const relativePath of ['tile.json', 'index.md']) {
-            const fullPath = path.join(tile.directory, relativePath);
-            if (!fs.existsSync(fullPath)) {
-              throw new Error(`Missing exported asset ${relativePath} for ${tile.tileName}`);
-            }
-          }
-          for (const skillName of tile.skills) {
-            const skillPath = path.join(tile.directory, 'skills', skillName, 'SKILL.md');
-            if (!fs.existsSync(skillPath)) {
-              throw new Error(`Missing exported skill ${skillName}`);
-            }
-          }
-        }
-      },
-    },
-    {
-      id: 'TESSL-03',
-      desc: 'workspace override produces publishable workspace/tile names without mutating source config',
-      fn: () => {
-        const overridden = exportTiles({
-          outDir: tempDir,
-          workspace: 'igorganapolsky',
-        });
-        const manifest = JSON.parse(
-          fs.readFileSync(path.join(overridden[0].directory, 'tile.json'), 'utf8')
-        );
-
-        if (!manifest.name.startsWith('igorganapolsky/')) {
-          throw new Error('Workspace override did not flow into tile manifest');
-        }
-
-        const config = loadTileConfig();
-        if (config.defaultWorkspace !== 'thumbgate') {
-          throw new Error('Source config mutated during export');
-        }
-      },
-    },
-    {
-      id: 'TESSL-04',
-      desc: 'generated docs include install guidance plus proof pack links',
-      fn: () => {
-        exportTiles({ outDir: tempDir });
-        const docs = fs.readFileSync(path.join(tempDir, 'agent-memory', 'index.md'), 'utf8');
-
-        if (!docs.includes('tessl install thumbgate/agent-memory')) {
-          throw new Error('Install command missing from generated docs');
-        }
-        if (!docs.includes('VERIFICATION_EVIDENCE.md')) {
-          throw new Error('Verification evidence link missing from generated docs');
-        }
-        if (!docs.includes('proof/compatibility/report.json')) {
-          throw new Error('Compatibility proof link missing from generated docs');
-        }
-      },
-    },
-    {
-      id: 'TESSL-05',
-      desc: 'skill verification command succeeds against the canonical skills',
-      fn: () => {
-        const result = verifyTiles();
-
-        if (!result.ok || result.tileCount !== 2) {
-          throw new Error('Tessl skill verification did not pass');
-        }
-      },
-    },
-    {
-      id: 'TESSL-06',
-      desc: 'publish workflow validates and exports before secret-gated Tessl publish',
-      fn: () => {
-        const workflow = fs.readFileSync(
-          path.join(ROOT, '.github', 'workflows', 'publish-tessl.yml'),
-          'utf8'
-        );
-
-        if (!/npm run tessl:verify/.test(workflow)) {
-          throw new Error('Workflow must verify Tessl tiles before publish');
-        }
-        if (!/npm run tessl:export -- --out-dir=.artifacts\/tessl/.test(workflow)) {
-          throw new Error('Workflow must export Tessl tiles before publish');
-        }
-        if (!/Plan Tessl publish action/.test(workflow)) {
-          throw new Error('Workflow must plan Tessl publish before publish matrix runs');
-        }
-        if (!/TESSL_API_TOKEN:\s*\$\{\{\s*secrets\.TESSL_API_TOKEN\s*\}\}/.test(workflow)) {
-          throw new Error('Workflow gate must source TESSL_API_TOKEN from secrets');
-        }
-        if (!/if:\s*\$\{\{\s*needs\.plan_publish\.outputs\.should_publish == 'true'\s*\}\}/.test(workflow)) {
-          throw new Error('Workflow publish job must be gated on the plan_publish output');
-        }
-        if (!/uses:\s*tesslio\/publish@main/.test(workflow)) {
-          throw new Error('Workflow must use the official Tessl publish action');
-        }
-      },
-    },
-  ];
-
-  console.log('Tessl Distribution - Proof Gate\n');
-  console.log('Checking requirements:\n');
-
-  for (const check of checks) {
-    try {
-      await check.fn();
-      results.passed++;
-      results.requirements[check.id] = { status: 'pass', desc: check.desc };
-      console.log(`  PASS  ${check.id}: ${check.desc}`);
-    } catch (error) {
-      results.failed++;
-      results.requirements[check.id] = {
-        status: 'fail',
-        desc: check.desc,
-        error: error.message,
-      };
-      console.error(`  FAIL  ${check.id}: ${error.message}`);
-    }
-  }
-
-  fs.rmSync(tempDir, { recursive: true, force: true });
-  fs.mkdirSync(proofDir, { recursive: true });
-
-  const report = {
-    phase: '12-tessl-distribution',
-    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 = [
-    '# Tessl Distribution 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,
-};

package/scripts/prove-training-export.js

@@ -1,325 +0,0 @@
-#!/usr/bin/env node
-/**
- * prove-training-export.js
- *
- * Smoke-test gate for Phase 10: Training Export
- * Verifies all export formats + DPO validation gate work end-to-end.
- * Writes machine-readable JSON + human-readable markdown to proof/.
- */
-
-'use strict';
-
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { execSync } = require('child_process');
-const { ensureDir } = require('./fs-utils');
-
-const ROOT = path.join(__dirname, '..');
-function getProofDir() {
-  return process.env.THUMBGATE_PROOF_DIR || path.join(ROOT, 'proof');
-}
-
-
-function runTests() {
-  try {
-    const output = execSync('node --test tests/training-export.test.js', {
-      cwd: ROOT,
-      encoding: 'utf-8',
-      stdio: ['pipe', 'pipe', 'pipe'],
-    });
-    return output;
-  } catch (err) {
-    return err.stdout || err.stderr || String(err);
-  }
-}
-
-function parseTestOutput(output) {
-  const passMatch = output.match(/ℹ pass (\d+)/);
-  const failMatch = output.match(/ℹ fail (\d+)/);
-  const passed = passMatch ? parseInt(passMatch[1], 10) : 0;
-  const failed = failMatch ? parseInt(failMatch[1], 10) : 0;
-  return { passed, failed };
-}
-
-function makeFeedbackEntry(overrides) {
-  return {
-    id: `fb_${Date.now()}_test`,
-    timestamp: new Date().toISOString(),
-    signal: 'positive',
-    feedback: 'up',
-    reward: 1,
-    context: 'Test context for smoke test',
-    tags: ['testing'],
-    richContext: { domain: 'testing', outcomeCategory: 'quick-success' },
-    ...overrides,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Smoke test: PyTorch JSON export (XPRT-01)
-// ---------------------------------------------------------------------------
-function smokePyTorchExport() {
-  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'prove-xprt1-'));
-  try {
-    delete require.cache[require.resolve('./export-training.js')];
-    const m = require('./export-training.js');
-
-    fs.mkdirSync(path.join(tmpDir, 'training-data'), { recursive: true });
-
-    const entries = [
-      makeFeedbackEntry({ context: 'Implemented TDD correctly' }),
-      makeFeedbackEntry({ signal: 'negative', feedback: 'down', reward: -1, context: 'Skipped validation' }),
-    ];
-    fs.writeFileSync(
-      path.join(tmpDir, 'feedback-log.jsonl'),
-      entries.map((e) => JSON.stringify(e)).join('\n')
-    );
-
-    const outPath = path.join(tmpDir, 'pytorch.json');
-    const result = m.exportPyTorchJSON(tmpDir, outPath);
-
-    if (!fs.existsSync(result.outputPath)) throw new Error('Output file not created');
-    const data = JSON.parse(fs.readFileSync(result.outputPath, 'utf-8'));
-    if (!data.metadata) throw new Error('Missing metadata');
-    if (data.metadata.format !== 'pytorch-dpo') throw new Error('Wrong format');
-    if (!Array.isArray(data.pairs)) throw new Error('Missing pairs array');
-    if (!Array.isArray(data.sequences)) throw new Error('Missing sequences array');
-
-    // Verify pair structure when pairs exist
-    if (data.pairs.length > 0) {
-      const pair = data.pairs[0];
-      if (!('prompt' in pair)) throw new Error('pair missing prompt');
-      if (!('chosen' in pair)) throw new Error('pair missing chosen');
-      if (!('rejected' in pair)) throw new Error('pair missing rejected');
-    }
-
-    return { passed: true, pairCount: result.pairCount, format: data.metadata.format };
-  } catch (err) {
-    return { passed: false, error: err.message };
-  } finally {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Smoke test: CSV export (XPRT-02)
-// ---------------------------------------------------------------------------
-function smokeCsvExport() {
-  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'prove-xprt2-'));
-  try {
-    delete require.cache[require.resolve('./export-training.js')];
-    const m = require('./export-training.js');
-
-    fs.mkdirSync(path.join(tmpDir, 'training-data'), { recursive: true });
-
-    const entries = [
-      makeFeedbackEntry({ context: 'Works great' }),
-      makeFeedbackEntry({ signal: 'negative', feedback: 'down', reward: -1, context: 'Has issues' }),
-    ];
-    fs.writeFileSync(
-      path.join(tmpDir, 'feedback-log.jsonl'),
-      entries.map((e) => JSON.stringify(e)).join('\n')
-    );
-
-    const outPath = path.join(tmpDir, 'summary.csv');
-    const result = m.exportCSV(tmpDir, outPath);
-
-    if (!fs.existsSync(result.outputPath)) throw new Error('CSV not created');
-    const csv = fs.readFileSync(result.outputPath, 'utf-8');
-    const lines = csv.split('\n');
-    const headers = lines[0].split(',');
-
-    const required = ['id', 'timestamp', 'signal', 'reward', 'context'];
-    for (const h of required) {
-      if (!headers.includes(h)) throw new Error(`CSV missing column: ${h}`);
-    }
-    if (result.rowCount !== 2) throw new Error(`Expected 2 rows, got ${result.rowCount}`);
-
-    return { passed: true, rowCount: result.rowCount, headers };
-  } catch (err) {
-    return { passed: false, error: err.message };
-  } finally {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Smoke test: Action analysis (XPRT-03)
-// ---------------------------------------------------------------------------
-function smokeActionAnalysis() {
-  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'prove-xprt3-'));
-  try {
-    delete require.cache[require.resolve('./export-training.js')];
-    const m = require('./export-training.js');
-
-    fs.mkdirSync(path.join(tmpDir, 'training-data'), { recursive: true });
-    fs.writeFileSync(path.join(tmpDir, 'feedback-log.jsonl'), '');
-
-    const outPath = path.join(tmpDir, 'actions.json');
-    const { report } = m.exportActionAnalysis(tmpDir, outPath);
-
-    if (!report.summary) throw new Error('Missing summary');
-    if (!report.actionPatterns) throw new Error('Missing actionPatterns');
-    if (!Array.isArray(report.topFailureModes)) throw new Error('Missing topFailureModes');
-    if (!Array.isArray(report.recommendations)) throw new Error('Missing recommendations');
-
-    return { passed: true, fields: Object.keys(report) };
-  } catch (err) {
-    return { passed: false, error: err.message };
-  } finally {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Smoke test: validateMemoryStructure gate (XPRT-04)
-// ---------------------------------------------------------------------------
-function smokeValidateMemoryStructure() {
-  try {
-    delete require.cache[require.resolve('./export-training.js')];
-    const m = require('./export-training.js');
-
-    // Valid entry
-    const valid = m.validateMemoryStructure({
-      title: 'SUCCESS: Test passed',
-      content: 'The implementation was correct and tests verified.',
-      category: 'learning',
-      tags: ['testing'],
-    });
-    if (!valid.valid) throw new Error('Valid entry rejected: ' + valid.issues.join(', '));
-
-    // Missing 'chosen' in DPO export
-    const missingChosen = m.validateMemoryStructure({
-      title: 'PREFERENCE: Good vs bad',
-      content: 'Comparison of approaches.',
-      category: 'preference',
-      tags: ['arch'],
-      _dpoExport: true,
-      prompt: 'Which approach?',
-      // chosen is missing
-      rejected: 'The bad approach',
-    });
-    if (missingChosen.valid) throw new Error('Should have rejected missing chosen field');
-    if (!missingChosen.issues.some((i) => i.includes('chosen'))) {
-      throw new Error('Issue should mention chosen field');
-    }
-
-    return {
-      passed: true,
-      validEntryAccepted: valid.valid,
-      missingChosenRejected: !missingChosen.valid,
-      missingChosenIssues: missingChosen.issues,
-    };
-  } catch (err) {
-    return { passed: false, error: err.message };
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Main
-// ---------------------------------------------------------------------------
-async function main() {
-  console.log('Running Phase 10: Training Export proof gate...\n');
-
-  const testOutput = runTests();
-  const { passed: testsPassed, failed: testsFailed } = parseTestOutput(testOutput);
-
-  const pytorch = smokePyTorchExport();
-  const csv = smokeCsvExport();
-  const actions = smokeActionAnalysis();
-  const gate = smokeValidateMemoryStructure();
-
-  const allPassed = testsFailed === 0 && pytorch.passed && csv.passed && actions.passed && gate.passed;
-
-  const report = {
-    phase: 10,
-    name: 'Training Export',
-    requirements: ['XPRT-01', 'XPRT-02', 'XPRT-03', 'XPRT-04', 'XPRT-05'],
-    generatedAt: new Date().toISOString(),
-    testResults: {
-      passed: testsPassed,
-      failed: testsFailed,
-      suiteFile: 'tests/training-export.test.js',
-    },
-    smokeTests: {
-      pytorchExport: pytorch,
-      csvExport: csv,
-      actionAnalysis: actions,
-      validateMemoryStructure: gate,
-    },
-    overallPassed: allPassed,
-  };
-
-  const proofDir = getProofDir();
-  ensureDir(proofDir);
-  const jsonPath = path.join(proofDir, 'training-export-report.json');
-  const mdPath = path.join(proofDir, 'training-export-report.md');
-
-  fs.writeFileSync(jsonPath, JSON.stringify(report, null, 2));
-
-  const status = allPassed ? 'PASSED' : 'FAILED';
-  const md = `# Phase 10: Training Export — Proof Report
-
-**Status:** ${status}
-**Generated:** ${report.generatedAt}
-**Requirements:** ${report.requirements.join(', ')}
-
-## Test Results
-
-| Suite | Passed | Failed |
-|-------|--------|--------|
-| training-export.test.js | ${testsPassed} | ${testsFailed} |
-
-## Smoke Tests
-
-### PyTorch JSON Export (XPRT-01)
-- Passed: ${pytorch.passed}
-${pytorch.passed ? `- Pair count: ${pytorch.pairCount}\n- Format: ${pytorch.format}` : `- Error: ${pytorch.error}`}
-
-### CSV Summary Export (XPRT-02)
-- Passed: ${csv.passed}
-${csv.passed ? `- Row count: ${csv.rowCount}\n- Headers: ${csv.headers ? csv.headers.join(', ') : 'N/A'}` : `- Error: ${csv.error}`}
-
-### Action Analysis Report (XPRT-03)
-- Passed: ${actions.passed}
-${actions.passed ? `- Report fields: ${actions.fields ? actions.fields.join(', ') : 'N/A'}` : `- Error: ${actions.error}`}
-
-### DPO Export Gate — validateMemoryStructure (XPRT-04)
-- Passed: ${gate.passed}
-${gate.passed ? `- Valid entry accepted: ${gate.validEntryAccepted}\n- Missing 'chosen' field rejected: ${gate.missingChosenRejected}` : `- Error: ${gate.error}`}
-
-## Requirements Coverage
-
-| Requirement | Description | Status |
-|-------------|-------------|--------|
-| XPRT-01 | PyTorch JSON export with prompt/chosen/rejected pairs | ${pytorch.passed ? 'PASS' : 'FAIL'} |
-| XPRT-02 | CSV summary export with correct headers and escaping | ${csv.passed ? 'PASS' : 'FAIL'} |
-| XPRT-03 | Action analysis report from feedback sequences | ${actions.passed ? 'PASS' : 'FAIL'} |
-| XPRT-04 | validateMemoryStructure() gates DPO export | ${gate.passed ? 'PASS' : 'FAIL'} |
-| XPRT-05 | All export features have unit tests (${testsPassed} tests, ${testsFailed} failures) | ${testsFailed === 0 ? 'PASS' : 'FAIL'} |
-
-## Files Created
-
-- \`scripts/export-training.js\` — PyTorch JSON, CSV, action analysis exports + validateMemoryStructure gate
-- \`tests/training-export.test.js\` — ${testsPassed} unit tests covering all formats, gate rejection, edge cases
-- \`scripts/prove-training-export.js\` — This proof gate script
-`;
-
-  fs.writeFileSync(mdPath, md);
-
-  console.log(`Status: ${status}`);
-  console.log(`Tests: ${testsPassed} passed, ${testsFailed} failed`);
-  console.log(`PyTorch smoke: ${pytorch.passed ? 'PASS' : 'FAIL'}`);
-  console.log(`CSV smoke: ${csv.passed ? 'PASS' : 'FAIL'}`);
-  console.log(`Action analysis smoke: ${actions.passed ? 'PASS' : 'FAIL'}`);
-  console.log(`validateMemoryStructure gate: ${gate.passed ? 'PASS' : 'FAIL'}`);
-  console.log(`\nReport written to: ${mdPath}`);
-
-  process.exit(allPassed ? 0 : 1);
-}
-
-main().catch((err) => {
-  console.error('prove-training-export failed:', err.message);
-  process.exit(1);
-});

package/scripts/prove-workflow-contract.js

@@ -1,112 +0,0 @@
-#!/usr/bin/env node
-const fs = require('node:fs');
-const path = require('node:path');
-const { ensureDir } = require('./fs-utils');
-const {
-  runWorkflowContractValidation,
-} = require('./validate-workflow-contract');
-
-const PROJECT_ROOT = path.join(__dirname, '..');
-const DEFAULT_PROOF_DIR = path.join(PROJECT_ROOT, 'proof', 'workflow-contract');
-
-
-function toMarkdown(report) {
-  const lines = [
-    '# Workflow Contract Proof Report',
-    '',
-    `Generated: ${report.generatedAt}`,
-    '',
-    `Summary: ${report.summary.passed} passed, ${report.summary.failed} failed`,
-    '',
-    '## Validated Files',
-    '',
-    ...Object.values(report.files).map((filePath) => `- \`${filePath}\``),
-    '',
-    '## Checks',
-    '',
-  ];
-
-  report.checks.forEach((check) => {
-    lines.push(`- ${check.name}: ${check.passed ? 'PASS' : 'FAIL'}`);
-  });
-
-  if (report.issues.length > 0) {
-    lines.push('');
-    lines.push('## Issues');
-    lines.push('');
-    report.issues.forEach((issue) => {
-      lines.push(`- ${issue}`);
-    });
-  }
-
-  return `${lines.join('\n')}\n`;
-}
-
-function runWorkflowContractProof(options = {}) {
-  const proofDir = options.proofDir || process.env.THUMBGATE_WORKFLOW_CONTRACT_PROOF_DIR || DEFAULT_PROOF_DIR;
-  const writeArtifacts = options.writeArtifacts !== false;
-  const validation = runWorkflowContractValidation({ projectRoot: options.projectRoot || PROJECT_ROOT });
-
-  const report = {
-    generatedAt: validation.generatedAt,
-    files: validation.files,
-    checks: [
-      {
-        name: 'workflow.contract.complete',
-        passed: validation.ok,
-        details: {
-          headingsFound: validation.details.workflow ? validation.details.workflow.headingsFound : [],
-          proofCommandsFound: validation.details.workflow ? validation.details.workflow.proofCommandsFound : [],
-        },
-      },
-      {
-        name: 'issue.template.complete',
-        passed: validation.ok,
-        details: {
-          fieldIdsFound: validation.details.issueTemplate ? validation.details.issueTemplate.fieldIdsFound : [],
-        },
-      },
-      {
-        name: 'pull_request.template.complete',
-        passed: validation.ok,
-        details: {
-          sectionsFound: validation.details.pullRequestTemplate ? validation.details.pullRequestTemplate.sectionsFound : [],
-        },
-      },
-      {
-        name: 'readme.links.contracts',
-        passed: validation.ok,
-        details: validation.details.readme || {},
-      },
-    ],
-    issues: validation.issues.slice(),
-    summary: {
-      passed: validation.ok ? 4 : 0,
-      failed: validation.ok ? 0 : 4,
-    },
-  };
-
-  if (writeArtifacts) {
-    ensureDir(proofDir);
-    fs.writeFileSync(path.join(proofDir, 'report.json'), JSON.stringify(report, null, 2));
-    fs.writeFileSync(path.join(proofDir, 'report.md'), toMarkdown(report));
-  }
-
-  return report;
-}
-
-if (require.main === module) {
-  const report = runWorkflowContractProof();
-  if (report.summary.failed > 0) {
-    console.error(toMarkdown(report));
-    process.exit(1);
-  }
-
-  console.log(toMarkdown(report));
-}
-
-module.exports = {
-  DEFAULT_PROOF_DIR,
-  runWorkflowContractProof,
-  toMarkdown,
-};