thumbgate 1.4.2 → 1.4.4

package/scripts/prove-local-intelligence.js

@@ -1,340 +0,0 @@
-#!/usr/bin/env node
-'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, '..');
-const DEFAULT_PROOF_DIR = process.env.THUMBGATE_PROOF_DIR || path.join(ROOT, 'proof');
-
-
-function runTests() {
-  try {
-    return execSync(
-      'node --test tests/local-model-profile.test.js tests/model-tier-router.test.js tests/profile-router.test.js tests/risk-scorer.test.js tests/vector-store.test.js tests/feedback-sequences.test.js tests/feedback-history-distiller.test.js tests/feedback-loop.test.js',
-      { cwd: ROOT, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }
-    );
-  } catch (err) {
-    return err.stdout || err.stderr || String(err);
-  }
-}
-
-function parseTestOutput(output) {
-  const passMatch = output.match(/ℹ pass (\d+)/);
-  const failMatch = output.match(/ℹ fail (\d+)/);
-  return {
-    passed: passMatch ? Number(passMatch[1]) : 0,
-    failed: failMatch ? Number(failMatch[1]) : 0,
-  };
-}
-
-async function main() {
-  const output = runTests();
-  const testResults = parseTestOutput(output);
-  const proofDir = DEFAULT_PROOF_DIR;
-  ensureDir(proofDir);
-
-  const tmpFeedbackDir = fs.mkdtempSync(path.join(os.tmpdir(), 'thumbgate-local-intel-'));
-  const report = {
-    generatedAt: new Date().toISOString(),
-    checks: [],
-    summary: { passed: 0, failed: 0 },
-    testResults,
-  };
-
-  function addResult(id, passed, evidence) {
-    report.checks.push({ id, passed, evidence });
-    if (passed) report.summary.passed += 1;
-    else report.summary.failed += 1;
-  }
-
-  try {
-    const {
-      writeModelFitReport,
-      detectInferenceBackend,
-      recommendInferenceBackend,
-    } = require('./local-model-profile');
-    const { recommendExecutionPlan } = require('./model-tier-router');
-    const { routeInference } = require('./profile-router');
-    const { reportPath, report: modelFitReport } = writeModelFitReport(tmpFeedbackDir, {
-      resolved: require('./local-model-profile').resolveEmbeddingProfile({
-        THUMBGATE_RAM_BYTES_OVERRIDE: String(4 * 1024 ** 3),
-        THUMBGATE_CPU_COUNT_OVERRIDE: '4',
-      }),
-    });
-    addResult(
-      'FIT-01',
-      fs.existsSync(reportPath) && modelFitReport.selectedProfile.id === 'compact',
-      `model-fit report written; selected profile=${modelFitReport.selectedProfile.id}; maxChars=${modelFitReport.selectedProfile.maxChars}`
-    );
-
-    process.env.THUMBGATE_FEEDBACK_DIR = tmpFeedbackDir;
-    process.env.THUMBGATE_MODEL_FIT_PROFILE = 'quality';
-    process.env.THUMBGATE_VECTOR_FORCE_PRIMARY_FAILURE = 'true';
-    delete process.env.THUMBGATE_VECTOR_STUB_EMBED;
-    delete require.cache[require.resolve('./vector-store')];
-    const vectorStore = require('./vector-store');
-    vectorStore.setLanceLoaderForTests(async () => {
-      const tables = new Map();
-      return {
-        connect: async () => ({
-          tableNames: async () => [...tables.keys()],
-          openTable: async (name) => {
-            const rows = tables.get(name) || [];
-            return {
-              add: async (records) => {
-                rows.push(...records);
-                tables.set(name, rows);
-              },
-              search: () => ({
-                limit: (limit) => ({
-                  toArray: async () => rows.slice(0, limit),
-                }),
-              }),
-            };
-          },
-          createTable: async (name, records) => {
-            tables.set(name, [...records]);
-            return {
-              add: async (more) => {
-                const rows = tables.get(name) || [];
-                rows.push(...more);
-                tables.set(name, rows);
-              },
-            };
-          },
-        }),
-      };
-    });
-    vectorStore.setPipelineLoaderForTests(async (_task, model, opts) => async () => ({
-      data: Float32Array.from({ length: 384 }, (_, index) => (index === 0 ? 1 : 0)),
-      model,
-      opts,
-    }));
-    await vectorStore.upsertFeedback({
-      id: 'proof-local-intel',
-      signal: 'positive',
-      context: 'vector fallback proof',
-      tags: ['proof'],
-      timestamp: new Date().toISOString(),
-    });
-    const fallbackProfile = vectorStore.getLastEmbeddingProfile();
-    addResult(
-      'FIT-02',
-      Boolean(fallbackProfile && fallbackProfile.fallbackUsed),
-      `vector-store active profile=${fallbackProfile && fallbackProfile.activeProfile ? fallbackProfile.activeProfile.id : 'none'}; fallbackUsed=${fallbackProfile ? fallbackProfile.fallbackUsed : false}; reason=${fallbackProfile ? fallbackProfile.fallbackReason : 'n/a'}`
-    );
-
-    const sparseBackend = detectInferenceBackend({
-      THUMBGATE_PROVIDER_MODE: 'local',
-      THUMBGATE_LOCAL_MODEL_FAMILY: 'deepseek-r1',
-      THUMBGATE_LOCAL_MODEL_SERVER: 'sglang',
-      THUMBGATE_INDEXCACHE_ENABLED: 'true',
-    });
-    addResult(
-      'IDX-01',
-      sparseBackend.indexCacheEligible && sparseBackend.indexCacheEnabled,
-      `backend=${sparseBackend.id}; server=${sparseBackend.serverEngine}; eligible=${sparseBackend.indexCacheEligible}; enabled=${sparseBackend.indexCacheEnabled}`
-    );
-
-    const recommendation = recommendInferenceBackend({
-      type: 'large-context',
-      contextTokens: 240000,
-      tags: ['xmemory'],
-    }, {
-      THUMBGATE_PROVIDER_MODE: 'local',
-      THUMBGATE_LOCAL_MODEL_FAMILY: 'glm-4.5',
-      THUMBGATE_LOCAL_MODEL_SERVER: 'vllm',
-    });
-    addResult(
-      'IDX-02',
-      recommendation.recommendationClass === 'indexcache_eligible',
-      `class=${recommendation.recommendationClass}; backend=${recommendation.backend.id}; reason=${recommendation.reason}`
-    );
-
-    const executionPlan = recommendExecutionPlan({
-      type: 'code-edit',
-      contextTokens: 260000,
-      tags: ['retrieval-heavy'],
-    }, {
-      THUMBGATE_PROVIDER_MODE: 'local',
-      THUMBGATE_LOCAL_MODEL_FAMILY: 'deepseek-v3',
-      THUMBGATE_LOCAL_MODEL_SERVER: 'sglang',
-      THUMBGATE_INDEXCACHE_ENABLED: 'true',
-    });
-    addResult(
-      'IDX-03',
-      executionPlan.tier === 'frontier' && executionPlan.recommendationClass === 'indexcache_active',
-      `tier=${executionPlan.tier}; backend=${executionPlan.backendId}; class=${executionPlan.recommendationClass}`
-    );
-
-    const routed = routeInference({
-      toolName: 'verify_claim',
-      toolInput: { claim: 'long-context repo audit' },
-      taskType: 'large-context',
-      contextTokens: 220000,
-      tags: ['xmemory'],
-      env: {
-        THUMBGATE_PROVIDER_MODE: 'managed',
-      },
-    });
-    addResult(
-      'IDX-04',
-      routed.route === 'local' && routed.privacy.route === 'local',
-      `route=${routed.route}; privacy=${routed.privacy.route}; class=${routed.recommendationClass}`
-    );
-
-    delete require.cache[require.resolve('./feedback-loop')];
-    const { captureFeedback, analyzeFeedback } = require('./feedback-loop');
-    const { recordConversationEntry } = require('./feedback-history-distiller');
-    captureFeedback({
-      signal: 'up',
-      context: 'ran tests and included logs',
-      whatWorked: 'verification complete',
-      tags: ['testing', 'verification'],
-    });
-    captureFeedback({
-      signal: 'down',
-      context: 'skipped tests and missing logs caused failure',
-      whatWentWrong: 'verification skipped',
-      whatToChange: 'always run tests',
-      tags: ['debugging', 'verification'],
-    });
-    captureFeedback({
-      signal: 'up',
-      context: 'proof attached and verification complete',
-      whatWorked: 'full evidence',
-      tags: ['testing', 'verification'],
-    });
-    captureFeedback({
-      signal: 'down',
-      context: 'unsafe path and security risk caused rejection',
-      whatWentWrong: 'unsafe path',
-      whatToChange: 'validate paths',
-      tags: ['security'],
-    });
-    const clarification = captureFeedback({
-      signal: 'up',
-      context: 'thumbs up',
-      tags: ['verification'],
-    });
-    addResult(
-      'VETO-01',
-      clarification.status === 'clarification_required' && clarification.needsClarification === true,
-      `vague feedback status=${clarification.status}; prompt=${clarification.prompt || 'n/a'}`
-    );
-    captureFeedback({
-      signal: 'positive',
-      context: 'claimed success without logs',
-      whatWorked: 'Reviewer approved despite missing logs',
-      tags: ['verification'],
-      rubricScores: [
-        { criterion: 'verification_evidence', score: 5, judge: 'judge-a' },
-        { criterion: 'verification_evidence', score: 2, judge: 'judge-b', evidence: 'missing logs' },
-      ],
-      guardrails: {
-        testsPassed: false,
-        pathSafety: true,
-        budgetCompliant: true,
-      },
-    });
-    captureFeedback({
-      signal: 'down',
-      context: 'regression due to skipped verification',
-      whatWentWrong: 'regression shipped',
-      whatToChange: 'add regression tests',
-      tags: ['debugging', 'verification'],
-    });
-
-    const riskModelPath = path.join(tmpFeedbackDir, 'risk-model.json');
-    const analysis = analyzeFeedback();
-    addResult(
-      'RISK-01',
-      fs.existsSync(riskModelPath),
-      'risk-model artifact written'
-    );
-    addResult(
-      'RISK-02',
-      Boolean(analysis.boostedRisk && analysis.boostedRisk.exampleCount >= 6),
-      `boostedRisk exampleCount=${analysis.boostedRisk ? analysis.boostedRisk.exampleCount : 0}; mode=${analysis.boostedRisk ? analysis.boostedRisk.mode : 'none'}; topDomain=${analysis.boostedRisk && analysis.boostedRisk.highRiskDomains[0] ? analysis.boostedRisk.highRiskDomains[0].key : 'none'}`
-    );
-
-    const distilled = captureFeedback({
-      signal: 'down',
-      context: 'thumbs down',
-      chatHistory: [
-        { author: 'user', text: 'Do not use Tailwind in this repo.' },
-        { author: 'assistant', text: 'I used Tailwind classes in the hero rewrite.' },
-      ],
-      tags: ['ui'],
-    });
-    addResult(
-      'DISTILL-01',
-      distilled.accepted === true && /ignored a prior instruction/i.test(distilled.feedbackEvent.whatWentWrong || ''),
-      `accepted=${distilled.accepted}; whatWentWrong=${distilled.feedbackEvent.whatWentWrong || 'n/a'}`
-    );
-
-    recordConversationEntry({
-      author: 'assistant',
-      text: 'Ran npm test and attached the output before closing the task.',
-      source: 'proof',
-    }, { feedbackDir: tmpFeedbackDir });
-    const fallback = captureFeedback({
-      signal: 'up',
-      context: 'thumbs up',
-      allowLocalConversationFallback: true,
-      tags: ['verification'],
-    });
-    addResult(
-      'DISTILL-02',
-      fallback.accepted === true && /successful pattern/i.test(fallback.feedbackEvent.whatWorked || ''),
-      `accepted=${fallback.accepted}; whatWorked=${fallback.feedbackEvent.whatWorked || 'n/a'}`
-    );
-  } finally {
-    delete process.env.THUMBGATE_FEEDBACK_DIR;
-    delete process.env.THUMBGATE_MODEL_FIT_PROFILE;
-    delete process.env.THUMBGATE_VECTOR_FORCE_PRIMARY_FAILURE;
-    delete process.env.THUMBGATE_VECTOR_STUB_EMBED;
-    fs.rmSync(tmpFeedbackDir, { recursive: true, force: true });
-  }
-
-  const passed = report.summary.failed === 0 && report.testResults.failed === 0;
-  const jsonPath = path.join(proofDir, 'local-intelligence-report.json');
-  const mdPath = path.join(proofDir, 'local-intelligence-report.md');
-
-  fs.writeFileSync(jsonPath, `${JSON.stringify(report, null, 2)}\n`);
-
-  const lines = [
-    '# Local Intelligence Proof Report',
-    '',
-    `Status: ${passed ? 'PASSED' : 'FAILED'}`,
-    `Generated: ${report.generatedAt}`,
-    '',
-    '## Test Results',
-    '',
-    `- Passed: ${report.testResults.passed}`,
-    `- Failed: ${report.testResults.failed}`,
-    '',
-    '## Checks',
-    '',
-  ];
-
-  report.checks.forEach((check) => {
-    lines.push(`- ${check.id}: ${check.passed ? 'PASS' : 'FAIL'} — ${check.evidence}`);
-  });
-
-  fs.writeFileSync(mdPath, `${lines.join('\n')}\n`);
-
-  process.stdout.write(`Status: ${passed ? 'PASSED' : 'FAILED'}\n`);
-  process.stdout.write(`JSON report: ${jsonPath}\n`);
-  process.stdout.write(`Markdown report: ${mdPath}\n`);
-  process.exit(passed ? 0 : 1);
-}
-
-main().catch((err) => {
-  console.error(`prove-local-intelligence failed: ${err.message}`);
-  process.exit(1);
-});

package/scripts/prove-loop-closure.js

@@ -1,263 +0,0 @@
-'use strict';
-/**
- * Phase 8: Loop Closure — Proof Gate
- *
- * Validates all LOOP-01 through LOOP-05 requirements offline.
- * Mirrors the pattern of prove-attribution.js (mkdtempSync + env override + execSync).
- *
- * Usage:
- *   node scripts/prove-loop-closure.js
- *
- * Produces:
- *   proof/loop-closure-report.json
- *   proof/loop-closure-report.md
- */
-
-const { execSync } = require('child_process');
-const fs = require('fs');
-const os = require('os');
-const path = require('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, 'loop-closure-report.json'),
-    reportMd: path.join(proofDir, 'loop-closure-report.md'),
-  };
-}
-
-function run() {
-  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'thumbgate-loop-proof-'));
-  const results = { passed: 0, failed: 0, requirements: {} };
-  const { proofDir, reportJson, reportMd } = resolveProofPaths();
-
-  const checks = [
-    {
-      id: 'LOOP-01',
-      desc: 'feedback-to-rules.js: analyze() produces recurringIssues + toRules() emits NEVER bullets',
-      fn: () => {
-        delete require.cache[require.resolve('./feedback-to-rules')];
-        const m = require('./feedback-to-rules');
-        if (typeof m.parseFeedbackFile !== 'function') throw new Error('parseFeedbackFile not exported');
-        if (typeof m.classifySignal !== 'function') throw new Error('classifySignal not exported');
-        if (typeof m.analyze !== 'function') throw new Error('analyze not exported');
-        if (typeof m.toRules !== 'function') throw new Error('toRules not exported');
-
-        const ctx = 'Agent claimed done without running tests first';
-        const entries = [
-          { signal: 'negative', context: ctx },
-          { signal: 'negative', context: ctx },
-        ];
-        const report = m.analyze(entries);
-        if (report.recurringIssues.length < 1) throw new Error('Expected at least 1 recurring issue');
-        const rules = m.toRules(report);
-        if (!rules.includes('NEVER')) throw new Error('toRules must emit NEVER bullets');
-        if (!rules.startsWith('# Suggested Rules from Feedback Analysis')) {
-          throw new Error('toRules must start with header');
-        }
-      },
-    },
-    {
-      id: 'LOOP-02',
-      desc: 'plan-gate.js: validatePlan() rejects structurally invalid PRD, passes valid one',
-      fn: () => {
-        delete require.cache[require.resolve('./plan-gate')];
-        const m = require('./plan-gate');
-        if (typeof m.validatePlan !== 'function') throw new Error('validatePlan not exported');
-        if (typeof m.formatReport !== 'function') throw new Error('formatReport not exported');
-
-        // Invalid: missing required sections
-        const invalid = m.validatePlan('# Minimal plan\nNo sections here');
-        if (invalid.allPass) throw new Error('Expected allPass=false for structurally invalid PRD');
-
-        // Valid: all gates satisfied
-        const valid = m.validatePlan([
-          '# My Plan',
-          '',
-          '## Status',
-          'DRAFT',
-          '',
-          '## Clarifying Questions Resolved',
-          '| Q | A |',
-          '|---|---|',
-          '| q1 | a1 |',
-          '| q2 | a2 |',
-          '| q3 | a3 |',
-          '',
-          '## Contracts',
-          '```',
-          'interface Foo { bar: string }',
-          '```',
-          '',
-          '## Validation Checklist',
-          '- [ ] scenario 1',
-          '- [ ] scenario 2',
-        ].join('\n'));
-        if (!valid.allPass) throw new Error('Expected allPass=true for valid PRD');
-
-        const report = m.formatReport(valid);
-        if (!report.includes('RESULT: PASS')) throw new Error('formatReport must include RESULT: PASS');
-      },
-    },
-    {
-      id: 'LOOP-03',
-      desc: 'feedback-inbox-read.js: getNewEntries reads in cursor order, no re-reads on next call',
-      fn: () => {
-        delete require.cache[require.resolve('./feedback-inbox-read')];
-        const m = require('./feedback-inbox-read');
-        if (typeof m.getNewEntries !== 'function') throw new Error('getNewEntries not exported');
-        if (typeof m.readInbox !== 'function') throw new Error('readInbox not exported');
-        if (typeof m.loadCursor !== 'function') throw new Error('loadCursor not exported');
-        if (typeof m.saveCursor !== 'function') throw new Error('saveCursor not exported');
-
-        // Verify cursor filtering logic
-        const allEntries = [
-          { _lineIndex: 0, signal: 'negative' },
-          { _lineIndex: 1, signal: 'positive' },
-          { _lineIndex: 2, signal: 'negative' },
-        ];
-        const cursor = { lastLineIndex: 0 };
-        const afterFirst = allEntries.filter((e) => e._lineIndex > cursor.lastLineIndex);
-        if (afterFirst.length !== 2) throw new Error('Expected 2 entries after cursor=0');
-
-        const cursor2 = { lastLineIndex: 2 };
-        const afterAll = allEntries.filter((e) => e._lineIndex > cursor2.lastLineIndex);
-        if (afterAll.length !== 0) throw new Error('Expected 0 entries after cursor=2 (no re-reads)');
-
-        // Verify paths are exported
-        if (typeof m.INBOX_PATH !== 'string') throw new Error('INBOX_PATH must be exported string');
-        if (typeof m.CURSOR_PATH !== 'string') throw new Error('CURSOR_PATH must be exported string');
-      },
-    },
-    {
-      id: 'LOOP-04',
-      desc: 'feedback-to-memory.js: convertFeedbackToMemory() emits valid MCP memory format on round-trip',
-      fn: () => {
-        delete require.cache[require.resolve('./feedback-to-memory')];
-        const m = require('./feedback-to-memory');
-        if (typeof m.convertFeedbackToMemory !== 'function') {
-          throw new Error('convertFeedbackToMemory not exported');
-        }
-
-        // Valid negative → memory
-        const neg = m.convertFeedbackToMemory({
-          signal: 'negative',
-          context: 'Agent claimed fix without test evidence',
-          whatWentWrong: 'No tests were run before claiming done',
-          whatToChange: 'Always run tests before claiming done',
-          tags: ['verification', 'testing'],
-        });
-        if (!neg.ok) throw new Error(`Valid negative should return ok=true: ${neg.reason}`);
-        if (neg.actionType !== 'store-mistake') throw new Error('Expected actionType=store-mistake');
-        if (!neg.memory.title.startsWith('MISTAKE:')) throw new Error('Expected MISTAKE: prefix');
-        if (neg.memory.category !== 'error') throw new Error('Expected category=error');
-        if (!Array.isArray(neg.memory.tags)) throw new Error('Expected tags array');
-
-        // Valid positive → memory
-        const pos = m.convertFeedbackToMemory({
-          signal: 'positive',
-          whatWorked: 'Ran full test suite before claiming done',
-          tags: ['verification'],
-        });
-        if (!pos.ok) throw new Error(`Valid positive should return ok=true: ${pos.reason}`);
-        if (pos.actionType !== 'store-learning') throw new Error('Expected actionType=store-learning');
-        if (!pos.memory.title.startsWith('SUCCESS:')) throw new Error('Expected SUCCESS: prefix');
-
-        // Bare negative → rejected (no context)
-        const bare = m.convertFeedbackToMemory({ signal: 'negative' });
-        if (bare.ok) throw new Error('Bare negative without context should be rejected');
-      },
-    },
-    {
-      id: 'LOOP-05',
-      desc: 'test:loop-closure (node --test tests/loop-closure.test.js) passes with 0 failures',
-      fn: () => {
-        const out = execSync('node --test tests/loop-closure.test.js', {
-          cwd: ROOT,
-          env: { ...process.env, THUMBGATE_FEEDBACK_DIR: tmpDir },
-          encoding: 'utf8',
-          stdio: 'pipe',
-        });
-        const failMatch = out.match(/ℹ fail (\d+)/);
-        if (failMatch && parseInt(failMatch[1], 10) > 0) {
-          throw new Error(`Tests failed: ${failMatch[1]} failure(s)\n${out.slice(-500)}`);
-        }
-      },
-    },
-  ];
-
-  console.log('Phase 8: Loop Closure — Proof Gate\n');
-  console.log('Checking requirements:\n');
-
-  for (const check of checks) {
-    try {
-      check.fn();
-      results.passed++;
-      results.requirements[check.id] = { status: 'pass', desc: check.desc };
-      console.log(`  PASS  ${check.id}: ${check.desc}`);
-    } catch (err) {
-      results.failed++;
-      results.requirements[check.id] = {
-        status: 'fail',
-        desc: check.desc,
-        error: err.message,
-      };
-      console.error(`  FAIL  ${check.id}: ${err.message}`);
-    }
-  }
-
-  // Cleanup tmp dir
-  try {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  } catch {}
-
-  // Write proof artifacts
-  fs.mkdirSync(proofDir, { recursive: true });
-
-  const report = {
-    phase: '08-loop-closure',
-    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 md = [
-    '# Phase 8: Loop Closure — Proof Report',
-    '',
-    `Generated: ${report.generatedAt}`,
-    `Result: ${results.passed}/${checks.length} passed`,
-    '',
-    '## Requirements',
-    '',
-    ...Object.entries(results.requirements).map(([id, r]) => {
-      const checkbox = r.status === 'pass' ? '[x]' : '[ ]';
-      const errLine = r.error ? `\n  - Error: \`${r.error}\`` : '';
-      return `- ${checkbox} **${id}**: ${r.desc}${errLine}`;
-    }),
-    '',
-    '## Evidence',
-    '',
-    '- `scripts/feedback-to-rules.js` — Feedback pattern analysis + CLAUDE.md-compatible rule generation',
-    '- `scripts/plan-gate.js` — PRD structural validation gate (questions, contracts, checklist, status)',
-    '- `scripts/feedback-inbox-read.js` — Cursor-based inbox reader with no re-read guarantee',
-    '- `scripts/feedback-to-memory.js` — Stdin JSON → MCP memory format bridge with schema validation',
-    '- `tests/loop-closure.test.js` — 44 node:test cases covering all LOOP requirements',
-    '',
-  ].join('\n');
-
-  fs.writeFileSync(reportMd, md);
-
-  console.log(`\nPhase 8 proof: ${results.passed} passed, ${results.failed} failed`);
-  console.log(`Report: ${reportJson}`);
-
-  if (results.failed > 0) process.exit(1);
-}
-
-run();