@hegemonart/get-design-done 1.19.6 → 1.20.0

package/hooks/context-exhaustion.js

@@ -1,127 +0,0 @@
-#!/usr/bin/env node
-/**
- * context-exhaustion.js — PostToolUse hook
- *
- * Monitors context usage reported in the tool_response. When usage exceeds
- * THRESHOLD (default 85%), writes a <paused> resumption block to
- * .design/STATE.md so the next session can resume without losing context.
- *
- * Hook type: PostToolUse (any tool)
- * Input:  JSON on stdin { tool_name, tool_input, tool_response }
- * Output: JSON on stdout { continue, suppressOutput, message } or nothing
- */
-
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const readline = require('readline');
-
-const THRESHOLD = parseFloat(process.env.GDD_CONTEXT_THRESHOLD || '0.85');
-const STATE_PATH = path.join(process.cwd(), '.design', 'STATE.md');
-
-function now() {
-  return new Date().toISOString();
-}
-
-function extractContextUsage(toolResponse) {
-  // Claude Code injects context usage as a field in the tool response envelope.
-  // Try common field names used across Claude Code versions.
-  if (typeof toolResponse !== 'object' || toolResponse === null) return null;
-
-  // Direct field
-  if (typeof toolResponse.context_usage === 'number') return toolResponse.context_usage;
-  if (typeof toolResponse.contextUsage === 'number') return toolResponse.contextUsage;
-
-  // Nested under metadata
-  const meta = toolResponse.metadata || toolResponse.meta || {};
-  if (typeof meta.context_usage === 'number') return meta.context_usage;
-  if (typeof meta.contextUsage === 'number') return meta.contextUsage;
-
-  // Fraction string "0.87" or percentage "87%"
-  const raw = toolResponse.context_usage || toolResponse.contextUsage
-    || meta.context_usage || meta.contextUsage;
-  if (typeof raw === 'string') {
-    if (raw.endsWith('%')) return parseFloat(raw) / 100;
-    const n = parseFloat(raw);
-    if (!isNaN(n)) return n > 1 ? n / 100 : n;
-  }
-
-  return null;
-}
-
-function buildPausedBlock(toolName, usage) {
-  const pct = Math.round(usage * 100);
-  return `
-<paused>
-recorded: ${now()}
-trigger: context-exhaustion-hook
-context_usage: ${pct}%
-last_tool: ${toolName}
-
-## Resumption instructions
-
-Context reached ${pct}% during the previous session (threshold: ${Math.round(THRESHOLD * 100)}%).
-The session was auto-paused to preserve quality.
-
-To resume:
-1. Run \`/gdd:resume\` — it will read this block and restore working context
-2. If mid-plan: check .design/STATE.md for the last completed task
-3. Re-read the active PLAN.md to orient before continuing
-
-Intel store status at pause time:
-  ls .design/intel/files.json 2>/dev/null && echo "present" || echo "missing"
-</paused>
-`;
-}
-
-function stateFileHasPausedBlock() {
-  if (!fs.existsSync(STATE_PATH)) return false;
-  const content = fs.readFileSync(STATE_PATH, 'utf8');
-  return content.includes('<paused>') && content.includes('context-exhaustion-hook');
-}
-
-function appendPausedBlock(block) {
-  if (!fs.existsSync(path.dirname(STATE_PATH))) {
-    fs.mkdirSync(path.dirname(STATE_PATH), { recursive: true });
-  }
-  if (!fs.existsSync(STATE_PATH)) {
-    fs.writeFileSync(STATE_PATH, '# Design State\n\n', 'utf8');
-  }
-  fs.appendFileSync(STATE_PATH, block, 'utf8');
-}
-
-async function main() {
-  const rl = readline.createInterface({ input: process.stdin });
-  let inputData = '';
-  for await (const line of rl) inputData += line + '\n';
-
-  let parsed;
-  try { parsed = JSON.parse(inputData); } catch { process.exit(0); }
-
-  const toolName = parsed?.tool_name || 'unknown';
-  const toolResponse = parsed?.tool_response || {};
-
-  const usage = extractContextUsage(toolResponse);
-
-  // No usage data — cannot act
-  if (usage === null) process.exit(0);
-
-  // Below threshold — do nothing
-  if (usage < THRESHOLD) process.exit(0);
-
-  // At or above threshold — write paused block (only once per session)
-  if (stateFileHasPausedBlock()) process.exit(0);
-
-  const block = buildPausedBlock(toolName, usage);
-  appendPausedBlock(block);
-
-  const response = {
-    continue: true,
-    suppressOutput: false,
-    message: `gdd-context-exhaustion: Context at ${Math.round(usage * 100)}% — auto-recorded <paused> block in .design/STATE.md. Run /gdd:resume in the next session to continue.`,
-  };
-  process.stdout.write(JSON.stringify(response));
-}
-
-main().catch(err => { console.error('context-exhaustion hook error:', err); process.exit(0); });

package/hooks/gdd-read-injection-scanner.js

@@ -1,39 +0,0 @@
-#!/usr/bin/env node
-/**
- * gdd-read-injection-scanner — PostToolUse hook
- * Scans Read tool output for common prompt-injection patterns and warns
- * (does not block) when suspicious content is found in a read file.
- */
-
-const readline = require('readline');
-const path = require('path');
-const { INJECTION_PATTERNS: RAW_PATTERNS } = require(path.join(__dirname, '..', 'scripts', 'injection-patterns.cjs'));
-
-// The hook needs bare RegExp objects; extract them from the shared {name,re} entries.
-const INJECTION_PATTERNS = RAW_PATTERNS.map(p => p.re);
-
-async function main() {
-  const rl = readline.createInterface({ input: process.stdin });
-  let inputData = '';
-  for await (const line of rl) inputData += line + '\n';
-
-  let parsed;
-  try { parsed = JSON.parse(inputData); } catch { process.exit(0); }
-
-  if (parsed?.tool_name !== 'Read') process.exit(0);
-
-  const content = parsed?.tool_response?.content || '';
-  const matched = INJECTION_PATTERNS.some(p => p.test(content));
-  if (!matched) process.exit(0);
-
-  const file = parsed?.tool_input?.file_path || 'unknown';
-  const response = {
-    continue: true,
-    suppressOutput: false,
-    message: `gdd-injection-scanner: Suspicious prompt-injection pattern detected in content read from "${file}". Review before acting on instructions contained in that file.`,
-  };
-  process.stdout.write(JSON.stringify(response));
-  process.exit(0);
-}
-
-main().catch(() => process.exit(0));

package/scripts/aggregate-agent-metrics.js

@@ -1,173 +0,0 @@
-#!/usr/bin/env node
-/**
- * aggregate-agent-metrics.js — Incremental per-agent aggregator.
- *
- * Reads: .design/telemetry/costs.jsonl (append-only ledger from hooks/budget-enforcer.js)
- *        agents/{agent}.md (frontmatter source for default-tier, parallel-safe, reads-only,
- *        typical-duration-seconds)
- * Writes: .design/agent-metrics.json (atomic overwrite via tmp-file + rename)
- *
- * Invoked:
- *   1. Detached child of hooks/budget-enforcer.js after every telemetry write.
- *   2. Directly by /gdd:optimize skill as an explicit refresh step.
- *   3. Manually: `node scripts/aggregate-agent-metrics.js`
- *
- * OPT-09 contract: fields must match Phase 11 reflector's expectations
- * (see .planning/phases/11-self-improvement/11-02-PLAN.md).
- */
-
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-const CWD = process.cwd();
-const TELEMETRY_PATH = path.join(CWD, '.design', 'telemetry', 'costs.jsonl');
-const METRICS_PATH = path.join(CWD, '.design', 'agent-metrics.json');
-const PHASE_TOTALS_PATH = path.join(CWD, '.design', 'telemetry', 'phase-totals.json');
-const AGENTS_DIR = path.join(CWD, 'agents');
-
-// ---- frontmatter reader (no YAML dep) ----
-function readAgentFrontmatter(agentName) {
-  const p = path.join(AGENTS_DIR, `${agentName}.md`);
-  if (!fs.existsSync(p)) return {};
-  try {
-    const content = fs.readFileSync(p, 'utf8');
-    const fm = content.match(/^---\s*\n([\s\S]*?)\n---/);
-    if (!fm) return {};
-    const body = fm[1];
-    const get = (key) => {
-      const m = body.match(new RegExp(`^${key}:\\s*"?([^"\\n]+)"?`, 'm'));
-      return m ? m[1].trim() : null;
-    };
-    const defaultTier = get('default-tier');
-    const parallelSafe = get('parallel-safe');
-    const readsOnly = get('reads-only');
-    const typicalDuration = get('typical-duration-seconds');
-    return {
-      default_tier: defaultTier || null,
-      parallel_safe: parallelSafe === null ? null : /^(true|yes)$/i.test(parallelSafe),
-      reads_only: readsOnly === null ? null : /^(true|yes)$/i.test(readsOnly),
-      typical_duration_seconds: typicalDuration === null ? null : Number(typicalDuration) || null,
-    };
-  } catch {
-    return {};
-  }
-}
-
-// ---- telemetry reader ----
-function readTelemetryRows() {
-  if (!fs.existsSync(TELEMETRY_PATH)) return [];
-  const raw = fs.readFileSync(TELEMETRY_PATH, 'utf8');
-  const out = [];
-  for (const line of raw.split(/\r?\n/)) {
-    if (!line.trim()) continue;
-    try {
-      out.push(JSON.parse(line));
-    } catch {
-      // tolerant: skip malformed lines (partial write, truncation)
-    }
-  }
-  return out;
-}
-
-// ---- aggregator ----
-function aggregate(rows) {
-  const byAgent = new Map();
-  for (const r of rows) {
-    // Blocked rows represent a spawn that was denied at the hook — the agent
-    // never actually ran, so it must not contribute to spawn counts, cost, or
-    // token totals. Skip them here (mirror of the filter in aggregateByPhase).
-    if (r.block_reason) continue;
-    const agent = r.agent || 'unknown';
-    if (!byAgent.has(agent)) {
-      byAgent.set(agent, {
-        total_spawns: 0,
-        total_cost_usd: 0,
-        total_tokens_in: 0,
-        total_tokens_out: 0,
-        cache_hits: 0,
-        lazy_skips: 0,
-      });
-    }
-    const a = byAgent.get(agent);
-    a.total_spawns += 1;
-    a.total_cost_usd += Number(r.est_cost_usd || 0);
-    a.total_tokens_in += Number(r.tokens_in || 0);
-    a.total_tokens_out += Number(r.tokens_out || 0);
-    if (r.cache_hit === true) a.cache_hits += 1;
-    if (r.lazy_skipped === true) a.lazy_skips += 1;
-  }
-
-  const out = {};
-  for (const [agent, a] of byAgent.entries()) {
-    const fm = readAgentFrontmatter(agent);
-    const spawns = a.total_spawns || 1; // guard div-by-zero
-    out[agent] = {
-      typical_duration_seconds: fm.typical_duration_seconds,
-      default_tier: fm.default_tier,
-      parallel_safe: fm.parallel_safe,
-      reads_only: fm.reads_only,
-      total_spawns: a.total_spawns,
-      total_cost_usd: Number(a.total_cost_usd.toFixed(6)),
-      total_tokens_in: a.total_tokens_in,
-      total_tokens_out: a.total_tokens_out,
-      cache_hit_rate: Number((a.cache_hits / spawns).toFixed(4)),
-      lazy_skip_rate: Number((a.lazy_skips / spawns).toFixed(4)),
-    };
-  }
-  return out;
-}
-
-// ---- atomic write ----
-function writeAtomic(filePath, content) {
-  const dir = path.dirname(filePath);
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-  const tmp = path.join(dir, `.${path.basename(filePath)}.${process.pid}.${Date.now()}.tmp`);
-  fs.writeFileSync(tmp, content, 'utf8');
-  fs.renameSync(tmp, filePath);
-}
-
-// ---- phase totals aggregator (WR-02: avoids full JSONL replay in budget enforcer) ----
-function aggregateByPhase(rows) {
-  const byPhase = {};
-  for (const r of rows) {
-    // Blocked rows represent spawns that were denied by the hook — the agent
-    // never ran, so their est_cost_usd must not inflate cumulative phase spend.
-    // Counting them would make future hard-block and soft-threshold checks
-    // stricter than intended on every repeat cap hit.
-    if (r.block_reason) continue;
-    const phase = r.phase || 'unknown';
-    byPhase[phase] = (byPhase[phase] || 0) + Number(r.est_cost_usd || 0);
-  }
-  // Round to 6dp to match per-agent precision
-  for (const k of Object.keys(byPhase)) byPhase[k] = Number(byPhase[k].toFixed(6));
-  return byPhase;
-}
-
-// ---- main ----
-function main() {
-  const rows = readTelemetryRows();
-  const agents = aggregate(rows);
-  const payload = {
-    generated_at: new Date().toISOString(),
-    agents,
-  };
-  writeAtomic(METRICS_PATH, JSON.stringify(payload, null, 2) + '\n');
-  // Write lightweight phase-totals.json so budget-enforcer can read phase spend
-  // in O(1) without replaying the full JSONL on every agent spawn (WR-02).
-  const phaseTotals = {
-    generated_at: new Date().toISOString(),
-    totals: aggregateByPhase(rows),
-  };
-  writeAtomic(PHASE_TOTALS_PATH, JSON.stringify(phaseTotals, null, 2) + '\n');
-}
-
-try {
-  main();
-} catch (err) {
-  // Fail open: aggregator must never block the hook or /gdd:optimize flow.
-  process.stderr.write(`aggregate-agent-metrics: ${err.message}\n`);
-  process.exit(0);
-}

package/scripts/validate-frontmatter.cjs

@@ -1,68 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-// CI-friendly frontmatter validator for agents/*.md.
-// Enforces the Phase 7 agent frontmatter hygiene contract.
-// Exits 0 on success, 1 on any violation. One finding per stdout line.
-
-const fs = require('fs');
-const path = require('path');
-const { readFrontmatter } = require('../tests/helpers.cjs');
-
-const REQUIRED_FIELDS = [
-  'name',
-  'description',
-  'tools',
-  'color',
-  'parallel-safe',
-  'typical-duration-seconds',
-  'reads-only',
-  'writes',
-];
-
-function walkMd(dir) {
-  const out = [];
-  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-    const full = path.join(dir, entry.name);
-    if (entry.isDirectory()) out.push(...walkMd(full));
-    else if (entry.isFile() && entry.name.endsWith('.md')) out.push(full);
-  }
-  return out;
-}
-
-function main() {
-  const args = process.argv.slice(2).filter((a) => !a.startsWith('--'));
-  const targets = args.length ? args : ['agents/'];
-  const files = [];
-  for (const t of targets) {
-    if (!fs.existsSync(t)) {
-      console.error(`${t}: path does not exist`);
-      process.exit(1);
-    }
-    const stat = fs.statSync(t);
-    if (stat.isDirectory()) files.push(...walkMd(t));
-    else files.push(t);
-  }
-
-  let violations = 0;
-  for (const f of files) {
-    const fm = readFrontmatter(f);
-    if (Object.keys(fm).length === 0) {
-      // README.md under agents/ may have no frontmatter — skip
-      if (path.basename(f).toLowerCase() === 'readme.md') continue;
-      console.log(`${f}:frontmatter: missing`);
-      violations++;
-      continue;
-    }
-    for (const field of REQUIRED_FIELDS) {
-      if (!(field in fm) || fm[field] === undefined || fm[field] === null || fm[field] === '') {
-        console.log(`${f}:${field}: missing`);
-        violations++;
-      }
-    }
-  }
-
-  console.log(`summary: ${files.length} file(s) checked, ${violations} violation(s)`);
-  process.exit(violations === 0 ? 0 : 1);
-}
-
-main();

package/scripts/validate-schemas.cjs

@@ -1,242 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * validate-schemas.cjs
- *
- * Runs all Draft-07 JSON schemas under reference/schemas/ against their
- * corresponding subject files. Used by `npm run validate:schemas` and by the
- * CI validate job (added in plan 13-03).
- *
- * Primary path: spawn `npx --yes ajv-cli@5 validate -s <schema> -d <data>`.
- *
- * Fallback path: if `npx --yes` cannot fetch ajv-cli (offline/sandboxed
- * environment), fall back to a structural parse check: confirm each schema is
- * valid Draft-07 JSON (has $schema, type) and each data file is parseable JSON.
- * The fallback exits 0 on structural validity; CI will run the real ajv pass.
- *
- * Usage:
- *   node scripts/validate-schemas.cjs            # validate all schemas
- *   node scripts/validate-schemas.cjs --no-npx   # force fallback path
- *
- * Exit codes:
- *   0 — all present (schema, data) pairs pass
- *   1 — one or more pairs failed validation or a present schema is invalid
- */
-
-const { spawnSync } = require('child_process');
-const fs = require('fs');
-const path = require('path');
-
-const REPO_ROOT = path.resolve(__dirname, '..');
-const SCHEMA_DIR = path.join(REPO_ROOT, 'reference', 'schemas');
-
-/**
- * (schema, data) pairs. `dataPath` is relative to repo root. `required=true`
- * means the data file MUST exist in the repo; `required=false` means the data
- * file is generated at runtime (gitignored) and only the schema itself is
- * compiled.
- */
-const PAIRS = [
-  {
-    name: 'plugin',
-    schema: 'reference/schemas/plugin.schema.json',
-    data: '.claude-plugin/plugin.json',
-    required: true,
-  },
-  {
-    name: 'marketplace',
-    schema: 'reference/schemas/marketplace.schema.json',
-    data: '.claude-plugin/marketplace.json',
-    required: true,
-  },
-  {
-    name: 'hooks',
-    schema: 'reference/schemas/hooks.schema.json',
-    data: 'hooks/hooks.json',
-    required: true,
-  },
-  {
-    name: 'config',
-    schema: 'reference/schemas/config.schema.json',
-    data: '.design/config.json',
-    required: false,
-  },
-  {
-    name: 'intel',
-    schema: 'reference/schemas/intel.schema.json',
-    // intel files are runtime-only (gitignored). Only schema-compile it.
-    data: null,
-    required: false,
-  },
-  {
-    name: 'authority-snapshot',
-    schema: 'reference/schemas/authority-snapshot.schema.json',
-    // .design/authority-snapshot.json is runtime-only (gitignored via .design/).
-    // Only schema-compile it; Phase 13.2-02's watcher emits the data file at runtime.
-    data: null,
-    required: false,
-  },
-];
-
-const USE_NPX = !process.argv.includes('--no-npx');
-
-/**
- * Try running ajv-cli via npx. Returns { ok, stdout, stderr, status, fetchFailed }.
- * fetchFailed=true if npx couldn't fetch the package (offline); caller should fall back.
- *
- * We pass `-c ajv-formats` so schemas declaring `format: "date-time"` (etc.) are
- * validated against the standard JSON Schema formats plugin rather than being
- * rejected as unknown formats under ajv's strict mode. Schemas that declare no
- * formats (e.g., plugin, marketplace) are unaffected.
- */
-function runAjv(args) {
-  const injected = [...args];
-  // Inject `-c ajv-formats` after the sub-command (compile/validate) but before -s flags.
-  // Simpler: just append; ajv-cli accepts -c at any position.
-  injected.push('-c', 'ajv-formats');
-  const result = spawnSync(
-    'npx',
-    ['--yes', '-p', 'ajv-cli@5', '-p', 'ajv-formats@3', 'ajv', ...injected],
-    { encoding: 'utf8', cwd: REPO_ROOT }
-  );
-  const combined = (result.stdout || '') + (result.stderr || '');
-  // Heuristics for "network/fetch failed" — in that case fall back silently.
-  const fetchFailed =
-    result.status !== 0 &&
-    /(ENOTFOUND|ECONNREFUSED|ETIMEDOUT|getaddrinfo|network|unable to resolve|unable to fetch|offline|E404|registry\.npmjs\.org)/i.test(combined);
-  return {
-    ok: result.status === 0,
-    stdout: result.stdout || '',
-    stderr: result.stderr || '',
-    status: result.status,
-    fetchFailed,
-  };
-}
-
-/**
- * Fallback: confirm schema file is a valid Draft-07 JSON Schema (has $schema
- * pointing at draft-07). Confirm data file (if present) parses as JSON.
- */
-function structuralCheck(schemaAbs, dataAbs) {
-  let schema;
-  try {
-    schema = JSON.parse(fs.readFileSync(schemaAbs, 'utf8'));
-  } catch (e) {
-    return { ok: false, reason: `schema not parseable JSON: ${e.message}` };
-  }
-  if (!schema.$schema || !/draft-07/.test(schema.$schema)) {
-    return { ok: false, reason: `schema missing Draft-07 $schema declaration` };
-  }
-  if (dataAbs) {
-    try {
-      JSON.parse(fs.readFileSync(dataAbs, 'utf8'));
-    } catch (e) {
-      return { ok: false, reason: `data file not parseable JSON: ${e.message}` };
-    }
-  }
-  return { ok: true };
-}
-
-function main() {
-  const results = [];
-  let fallbackReason = null;
-
-  for (const pair of PAIRS) {
-    const schemaAbs = path.join(REPO_ROOT, pair.schema);
-    const dataAbs = pair.data ? path.join(REPO_ROOT, pair.data) : null;
-
-    if (!fs.existsSync(schemaAbs)) {
-      results.push({
-        name: pair.name,
-        ok: false,
-        via: 'missing-schema',
-        reason: `schema not found at ${pair.schema}`,
-      });
-      continue;
-    }
-
-    const dataPresent = dataAbs && fs.existsSync(dataAbs);
-
-    if (!dataPresent && pair.required) {
-      results.push({
-        name: pair.name,
-        ok: false,
-        via: 'missing-data',
-        reason: `required data file missing at ${pair.data}`,
-      });
-      continue;
-    }
-
-    if (!dataPresent) {
-      // Schema-only: compile to confirm the schema is structurally valid.
-      if (USE_NPX && !fallbackReason) {
-        const r = runAjv(['compile', '-s', schemaAbs]);
-        if (r.ok) {
-          results.push({ name: pair.name, ok: true, via: 'ajv-compile', note: 'data not present in repo tree — schema compiled only' });
-          continue;
-        }
-        if (r.fetchFailed) {
-          fallbackReason = `npx fetch failed: ${r.stderr.split('\n')[0] || 'unknown'}`;
-          // fall through to structural check below
-        } else {
-          results.push({ name: pair.name, ok: false, via: 'ajv-compile', reason: r.stderr || r.stdout || `exit ${r.status}` });
-          continue;
-        }
-      }
-      const s = structuralCheck(schemaAbs, null);
-      results.push({
-        name: pair.name,
-        ok: s.ok,
-        via: 'structural-compile',
-        reason: s.ok ? 'schema is valid Draft-07 (data not in repo tree)' : s.reason,
-      });
-      continue;
-    }
-
-    // Both schema and data present — full validation.
-    if (USE_NPX && !fallbackReason) {
-      const r = runAjv(['validate', '-s', schemaAbs, '-d', dataAbs]);
-      if (r.ok) {
-        results.push({ name: pair.name, ok: true, via: 'ajv-validate' });
-        continue;
-      }
-      if (r.fetchFailed) {
-        fallbackReason = `npx fetch failed: ${r.stderr.split('\n')[0] || 'unknown'}`;
-        // fall through to structural check below
-      } else {
-        results.push({ name: pair.name, ok: false, via: 'ajv-validate', reason: r.stderr || r.stdout || `exit ${r.status}` });
-        continue;
-      }
-    }
-    const s = structuralCheck(schemaAbs, dataAbs);
-    results.push({
-      name: pair.name,
-      ok: s.ok,
-      via: 'structural-validate',
-      reason: s.ok ? 'schema is valid Draft-07 and data parses as JSON' : s.reason,
-    });
-  }
-
-  // Report.
-  console.log('validate-schemas: results');
-  for (const r of results) {
-    const status = r.ok ? 'OK' : 'FAIL';
-    const note = r.note ? ` (${r.note})` : '';
-    const reason = r.reason ? ` — ${r.reason}` : '';
-    console.log(`  [${status}] ${r.name} via ${r.via}${note}${reason}`);
-  }
-  if (fallbackReason) {
-    console.log(`\nnote: ajv-cli via npx unavailable (${fallbackReason}); fell back to structural checks. CI will run the authoritative ajv pass.`);
-  }
-  const failed = results.filter(r => !r.ok);
-  console.log(`summary: ${results.length} pair(s) checked, ${failed.length} failure(s)`);
-
-  process.exit(failed.length === 0 ? 0 : 1);
-}
-
-if (require.main === module) {
-  main();
-}
-
-module.exports = { PAIRS };