thumbgate 0.9.13 → 1.0.0

package/scripts/hosted-job-launcher.js

@@ -0,0 +1,260 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const runner = require('./async-job-runner');
+const { buildHarnessJob } = require('./natural-language-harness');
+
+const RUNNER_SCRIPT_PATH = path.join(__dirname, 'async-job-runner.js');
+const MANAGED_DPO_EXPORT_SCRIPT_PATH = path.join(__dirname, 'managed-dpo-export.js');
+const BACKGROUND_LAUNCH_MODE = 'background';
+const INLINE_LAUNCH_MODE = 'inline';
+const IDLE_JOB_STATUSES = new Set(['queued', 'paused', 'resume_requested']);
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function ensureDir(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+
+function createHostedJobId(prefix = 'job') {
+  return `${prefix}_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+}
+
+function getStatePath(jobId) {
+  return runner.getJobRuntimePaths(jobId).statePath;
+}
+
+function writeStateFile(jobId, state) {
+  const statePath = getStatePath(jobId);
+  ensureDir(path.dirname(statePath));
+  fs.writeFileSync(statePath, JSON.stringify(state, null, 2) + '\n', 'utf8');
+  return state;
+}
+
+function updateIdleJobState(jobId, updater) {
+  const state = runner.readJobState(jobId);
+  if (!state) {
+    const error = new Error(`No persisted state found for job ${jobId}`);
+    error.statusCode = 404;
+    throw error;
+  }
+
+  if (!IDLE_JOB_STATUSES.has(state.status)) {
+    const error = new Error(`Job ${jobId} is not idle; current status is ${state.status}`);
+    error.statusCode = 409;
+    throw error;
+  }
+
+  return writeStateFile(jobId, updater({ ...state }));
+}
+
+function writeJobFile(jobId, jobSpec) {
+  const { jobDir } = runner.getJobRuntimePaths(jobId);
+  ensureDir(jobDir);
+  const jobFilePath = path.join(jobDir, 'job.json');
+  fs.writeFileSync(jobFilePath, JSON.stringify(jobSpec, null, 2) + '\n', 'utf8');
+  return jobFilePath;
+}
+
+function runInlineJob(args) {
+  if (args.runFile) {
+    runner.runJobFromFile(args.runFile);
+    return;
+  }
+
+  if (args.resumeJobId) {
+    runner.resumeJob(args.resumeJobId);
+    return;
+  }
+
+  throw new Error('Unsupported inline hosted job launch');
+}
+
+function launchRunner(args, options = {}) {
+  const launchMode = options.launchMode || process.env.THUMBGATE_HOSTED_JOB_LAUNCH_MODE || BACKGROUND_LAUNCH_MODE;
+  if (launchMode === INLINE_LAUNCH_MODE) {
+    runInlineJob(args);
+    return {
+      launchMode,
+      pid: process.pid,
+    };
+  }
+
+  const runnerArgs = [];
+  if (args.runFile) {
+    runnerArgs.push(`--run-file=${args.runFile}`);
+  } else if (args.resumeJobId) {
+    runnerArgs.push(`--resume=${args.resumeJobId}`);
+  } else {
+    throw new Error('Hosted job launch requires runFile or resumeJobId');
+  }
+
+  const child = spawn(process.execPath, [RUNNER_SCRIPT_PATH, ...runnerArgs], {
+    cwd: options.cwd || process.cwd(),
+    env: process.env,
+    detached: true,
+    stdio: 'ignore',
+  });
+  child.unref();
+  return {
+    launchMode,
+    pid: child.pid,
+  };
+}
+
+function prepareManagedJob(jobSpec, options = {}) {
+  const jobId = options.jobId || jobSpec.id || createHostedJobId(options.jobPrefix || 'job');
+  const finalSpec = {
+    ...jobSpec,
+    id: jobId,
+  };
+  const jobFilePath = writeJobFile(jobId, finalSpec);
+  const queuedState = runner.queueJob({
+    ...finalSpec,
+    jobFilePath,
+  });
+  return {
+    jobId,
+    jobFilePath,
+    state: queuedState,
+    jobSpec: {
+      ...finalSpec,
+      jobFilePath,
+    },
+  };
+}
+
+function launchManagedJob(jobSpec, options = {}) {
+  const prepared = prepareManagedJob(jobSpec, options);
+  const launch = launchRunner({ runFile: prepared.jobFilePath }, options);
+  return {
+    jobId: prepared.jobId,
+    jobFilePath: prepared.jobFilePath,
+    launchMode: launch.launchMode,
+    pid: launch.pid || null,
+    state: runner.readJobState(prepared.jobId) || prepared.state,
+  };
+}
+
+function buildManagedDpoExportJob(params = {}) {
+  const command = [
+    shellQuote(process.execPath),
+    shellQuote(MANAGED_DPO_EXPORT_SCRIPT_PATH),
+  ];
+
+  if (params.inputPath) {
+    command.push('--inputPath', shellQuote(params.inputPath));
+  } else if (params.memoryLogPath) {
+    command.push('--memoryLogPath', shellQuote(params.memoryLogPath));
+  }
+
+  if (params.outputPath) {
+    command.push('--outputPath', shellQuote(params.outputPath));
+  }
+
+  return {
+    tags: ['hosted-job', 'dpo-export'],
+    skill: 'hosted-dpo-export',
+    autoImprove: false,
+    verificationMode: 'none',
+    recordFeedback: false,
+    stages: [
+      {
+        name: 'export_dpo_pairs',
+        command: command.join(' '),
+      },
+    ],
+  };
+}
+
+function launchDpoExportJob(params = {}, options = {}) {
+  return launchManagedJob(buildManagedDpoExportJob(params), {
+    ...options,
+    jobPrefix: 'dpo_export',
+  });
+}
+
+function launchHarnessJob(identifier, inputs = {}, options = {}) {
+  const jobId = options.jobId || createHostedJobId('harness');
+  const jobSpec = buildHarnessJob(identifier, inputs, {
+    jobId,
+    skill: options.skill,
+    partnerProfile: options.partnerProfile,
+    autoImprove: options.autoImprove,
+  });
+  return launchManagedJob(jobSpec, {
+    ...options,
+    jobId,
+    jobPrefix: 'harness',
+  });
+}
+
+function resumeHostedJob(jobId, options = {}) {
+  const state = runner.readJobState(jobId);
+  if (!state) {
+    const error = new Error(`No persisted state found for job ${jobId}`);
+    error.statusCode = 404;
+    throw error;
+  }
+
+  if (['completed', 'failed', 'cancelled'].includes(state.status)) {
+    const error = new Error(`Job ${jobId} is already ${state.status}`);
+    error.statusCode = 409;
+    throw error;
+  }
+
+  const launch = launchRunner({ resumeJobId: jobId }, options);
+  return {
+    jobId,
+    launchMode: launch.launchMode,
+    pid: launch.pid || null,
+    state: runner.readJobState(jobId) || state,
+  };
+}
+
+function pauseQueuedJob(jobId, metadata = {}) {
+  runner.clearJobControl(jobId);
+  return updateIdleJobState(jobId, (state) => ({
+    ...state,
+    status: 'paused',
+    updatedAt: nowIso(),
+    pausedAt: nowIso(),
+    stopReason: metadata && metadata.reason ? metadata.reason : 'pause_requested',
+  }));
+}
+
+function cancelQueuedJob(jobId, metadata = {}) {
+  runner.clearJobControl(jobId);
+  return updateIdleJobState(jobId, (state) => ({
+    ...state,
+    status: 'cancelled',
+    updatedAt: nowIso(),
+    endedAt: nowIso(),
+    stopReason: metadata && metadata.reason ? metadata.reason : 'cancel_requested',
+  }));
+}
+
+module.exports = {
+  BACKGROUND_LAUNCH_MODE,
+  INLINE_LAUNCH_MODE,
+  buildManagedDpoExportJob,
+  cancelQueuedJob,
+  createHostedJobId,
+  launchDpoExportJob,
+  launchHarnessJob,
+  launchManagedJob,
+  pauseQueuedJob,
+  prepareManagedJob,
+  resumeHostedJob,
+};

package/scripts/managed-dpo-export.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const {
+  readJSONL,
+  exportDpoFromMemories,
+  DEFAULT_LOCAL_MEMORY_LOG,
+} = require('./export-dpo-pairs');
+
+function parseArgs(argv) {
+  const args = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (!token.startsWith('--')) continue;
+
+    const trimmed = token.slice(2);
+    const separatorIndex = trimmed.indexOf('=');
+    if (separatorIndex !== -1) {
+      const key = trimmed.slice(0, separatorIndex);
+      args[key] = trimmed.slice(separatorIndex + 1);
+      continue;
+    }
+
+    const next = argv[index + 1];
+    if (next && !next.startsWith('--')) {
+      args[trimmed] = next;
+      index += 1;
+      continue;
+    }
+
+    args[trimmed] = true;
+  }
+  if (args['input-path'] && !args.inputPath) args.inputPath = args['input-path'];
+  if (args['memory-log-path'] && !args.memoryLogPath) args.memoryLogPath = args['memory-log-path'];
+  if (args['output-path'] && !args.outputPath) args.outputPath = args['output-path'];
+  return args;
+}
+
+function loadMemories(args) {
+  if (args.inputPath) {
+    const raw = fs.readFileSync(path.resolve(args.inputPath), 'utf8');
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : parsed.memories || [];
+  }
+
+  const memoryLogPath = args.memoryLogPath
+    ? path.resolve(args.memoryLogPath)
+    : DEFAULT_LOCAL_MEMORY_LOG;
+  return readJSONL(memoryLogPath);
+}
+
+function run(argv = process.argv.slice(2)) {
+  const args = parseArgs(argv);
+  const memories = loadMemories(args);
+  const result = exportDpoFromMemories(memories);
+
+  let outputPath = null;
+  if (args.outputPath) {
+    outputPath = path.resolve(args.outputPath);
+    fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+    fs.writeFileSync(outputPath, result.jsonl, 'utf8');
+  }
+
+  const summary = {
+    pairs: result.pairs.length,
+    errors: result.errors.length,
+    learnings: result.learnings.length,
+    unpairedErrors: result.unpairedErrors.length,
+    unpairedLearnings: result.unpairedLearnings.length,
+    outputPath,
+  };
+  process.stdout.write(JSON.stringify(summary, null, 2) + '\n');
+  return summary;
+}
+
+if (require.main === module) {
+  try {
+    run();
+  } catch (error) {
+    console.error(error && error.message ? error.message : 'managed DPO export failed');
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  parseArgs,
+  run,
+};

package/scripts/obsidian-export.js

@@ -346,7 +346,6 @@ function exportGates(configPath, outputDir) {
   // Read auto-promoted gates if present (check common locations)
   const autoGatePaths = [
     path.join(path.dirname(configPath), '..', '.thumbgate', 'auto-promoted-gates.json'),
-    path.join(path.dirname(configPath), '..', '.rlhf', 'auto-promoted-gates.json'),
     path.join(path.dirname(configPath), '..', '.claude', 'memory', 'feedback', 'auto-promoted-gates.json'),
   ];
   for (const agPath of autoGatePaths) {

package/scripts/operational-integrity.js

@@ -174,20 +174,63 @@ function readPackageVersion(repoPath, ref = 'HEAD') {
 }
 
 function parseSemver(version) {
-  const match = String(version || '').trim().match(/^(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/);
+  const match = String(version || '').trim().match(/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+([0-9A-Za-z.-]+))?$/);
   if (!match) return null;
-  return match.slice(1).map((part) => Number(part));
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prerelease: match[4] ? match[4].split('.').filter(Boolean) : [],
+  };
+}
+
+function isNumericIdentifier(value) {
+  return /^\d+$/.test(String(value || ''));
+}
+
+function comparePrerelease(left = [], right = []) {
+  const maxLength = Math.max(left.length, right.length);
+  for (let index = 0; index < maxLength; index += 1) {
+    const leftIdentifier = left[index];
+    const rightIdentifier = right[index];
+
+    if (leftIdentifier === undefined) return -1;
+    if (rightIdentifier === undefined) return 1;
+    if (leftIdentifier === rightIdentifier) continue;
+
+    const leftIsNumeric = isNumericIdentifier(leftIdentifier);
+    const rightIsNumeric = isNumericIdentifier(rightIdentifier);
+
+    if (leftIsNumeric && rightIsNumeric) {
+      const leftValue = Number(leftIdentifier);
+      const rightValue = Number(rightIdentifier);
+      if (leftValue > rightValue) return 1;
+      if (leftValue < rightValue) return -1;
+      continue;
+    }
+
+    if (leftIsNumeric !== rightIsNumeric) {
+      return leftIsNumeric ? -1 : 1;
+    }
+
+    const lexical = String(leftIdentifier).localeCompare(String(rightIdentifier));
+    if (lexical !== 0) return lexical > 0 ? 1 : -1;
+  }
+
+  return 0;
 }
 
 function compareSemver(left, right) {
   const a = parseSemver(left);
   const b = parseSemver(right);
   if (!a || !b) return null;
-  for (let i = 0; i < 3; i += 1) {
-    if (a[i] > b[i]) return 1;
-    if (a[i] < b[i]) return -1;
-  }
-  return 0;
+  if (a.major !== b.major) return a.major > b.major ? 1 : -1;
+  if (a.minor !== b.minor) return a.minor > b.minor ? 1 : -1;
+  if (a.patch !== b.patch) return a.patch > b.patch ? 1 : -1;
+  if (a.prerelease.length === 0 && b.prerelease.length === 0) return 0;
+  if (a.prerelease.length === 0) return 1;
+  if (b.prerelease.length === 0) return -1;
+  return comparePrerelease(a.prerelease, b.prerelease);
 }
 
 function listChangedFilesAgainstBase(repoPath, baseBranch = DEFAULT_BASE_BRANCH, { fetchIfMissing = false } = {}) {

package/scripts/post-everywhere.js

@@ -25,6 +25,7 @@
 const fs = require('fs');
 const path = require('path');
 const { tagUrlsInText } = require('./social-analytics/utm');
+const { isDuplicate, recordPost } = require('./social-analytics/publishers/zernio');
 
 // ---------------------------------------------------------------------------
 // Publisher imports (lazy — only loaded when needed)
@@ -259,9 +260,18 @@ async function postEverywhere(filePath, { platforms, dryRun } = {}) {
       continue;
     }
 
+    // Dedup guard: skip platforms where identical content was posted in last 24h
+    const dedupContent = [parsed.title, parsed.body].filter(Boolean).join('\n');
+    if (!dryRun && isDuplicate(dedupContent, platform)) {
+      console.log(`[post-everywhere] ${platform}: SKIPPED — duplicate content within 24h`);
+      results[platform] = { skipped: true, reason: 'duplicate_content_24h' };
+      continue;
+    }
+
     try {
       console.log(`\n[post-everywhere] Posting to ${platform}...`);
       results[platform] = await dispatcher(parsed, dryRun);
+      if (!dryRun) recordPost(dedupContent, platform);
       console.log(`[post-everywhere] ${platform}: OK`);
     } catch (err) {
       console.error(`[post-everywhere] ${platform}: FAILED — ${err.message}`);

package/scripts/prove-lancedb.js

@@ -21,6 +21,48 @@ const { escapeMarkdownTableCell } = require('./markdown-escape');
 const ROOT = path.join(__dirname, '..');
 const PKG = JSON.parse(fs.readFileSync(path.join(ROOT, 'package.json'), 'utf-8'));
 
+function hasInstalledLanceDB() {
+  try {
+    require.resolve('@lancedb/lancedb');
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+
+function createInMemoryLanceLoader() {
+  const tables = new Map();
+  return async () => ({
+    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);
+          },
+        };
+      },
+    }),
+  });
+}
+
 function ensureDir(dirPath) {
   if (!fs.existsSync(dirPath)) {
     fs.mkdirSync(dirPath, { recursive: true });
@@ -33,6 +75,8 @@ function status(condition) {
 
 async function runProof(options = {}) {
   const proofDir = options.proofDir || process.env.THUMBGATE_PROOF_DIR || path.join(ROOT, 'proof');
+  const lanceInstalled = hasInstalledLanceDB();
+  const inMemoryLanceLoader = createInMemoryLanceLoader();
   const report = {
     phase: '04-lancedb-vector-storage',
     generated: new Date().toISOString(),
@@ -60,7 +104,11 @@ async function runProof(options = {}) {
     process.env.THUMBGATE_FEEDBACK_DIR = tmpDir;
     process.env.THUMBGATE_VECTOR_STUB_EMBED = 'true';
 
-    const { upsertFeedback, searchSimilar } = require('./vector-store');
+    const vectorStore = require('./vector-store');
+    if (!lanceInstalled) {
+      vectorStore.setLanceLoaderForTests(inMemoryLanceLoader);
+    }
+    const { upsertFeedback, searchSimilar } = vectorStore;
 
     const event = {
       id: 'proof-vec01',
@@ -84,7 +132,10 @@ async function runProof(options = {}) {
       vec01Evidence =
         `lancedb dir created at ${lanceDir}. ` +
         `upsertFeedback() resolved, searchSimilar() returned ${results.length} result(s) ` +
-        `including proof-vec01. Table name: thumbgate_memories.`;
+        `including proof-vec01. Table name: thumbgate_memories. ` +
+        (lanceInstalled
+          ? 'Proof used installed @lancedb/lancedb runtime.'
+          : 'Proof used an in-memory LanceDB-compatible loader because @lancedb/lancedb is not installed in this environment.');
     } else if (dirExists) {
       vec01Status = 'fail';
       vec01Evidence = `lancedb dir exists but searchSimilar() did not return proof-vec01. Got: ${JSON.stringify(results.map((r) => r.id))}`;
@@ -186,7 +237,11 @@ async function runProof(options = {}) {
     process.env.THUMBGATE_FEEDBACK_DIR = tmpDir;
     process.env.THUMBGATE_VECTOR_STUB_EMBED = 'true';
 
-    const { upsertFeedback: upsert2, searchSimilar: search2 } = require('./vector-store');
+    const vectorStore = require('./vector-store');
+    if (!lanceInstalled) {
+      vectorStore.setLanceLoaderForTests(inMemoryLanceLoader);
+    }
+    const { upsertFeedback: upsert2, searchSimilar: search2 } = vectorStore;
 
     // Upsert a second distinct record
     await upsert2({
@@ -209,7 +264,10 @@ async function runProof(options = {}) {
         `proof-vec01 present: ${hasVec01}. proof-vec04-b present: ${hasVec04b}. ` +
         `API: searchSimilar(queryText, limit=10) returns vector-ranked rows from thumbgate_memories table. ` +
         `Note: stub embed (THUMBGATE_VECTOR_STUB_EMBED=true) returns identical 384-dim unit vectors — ` +
-        `ranking is insertion-order with stub, cosine similarity with real ONNX model.`;
+        `ranking is insertion-order with stub, cosine similarity with real ONNX model. ` +
+        (lanceInstalled
+          ? 'Vector table access used installed @lancedb/lancedb runtime.'
+          : 'Vector table access used an in-memory LanceDB-compatible loader because @lancedb/lancedb is not installed in this environment.');
     } else {
       vec04Status = 'fail';
       vec04Evidence = `searchSimilar() returned 0 results after 2 upserts. Expected >= 1.`;

package/scripts/publish-decision.js

@@ -5,6 +5,14 @@ function normalizeBoolean(value) {
   return String(value).trim().toLowerCase() === 'true';
 }
 
+function isPrereleaseVersion(version) {
+  return /^\d+\.\d+\.\d+-[0-9A-Za-z.-]+$/.test(String(version || '').trim());
+}
+
+function getNpmTag(version) {
+  return isPrereleaseVersion(version) ? 'next' : 'latest';
+}
+
 function decidePublishPlan(options) {
   const currentSha = String(options.currentSha || '').trim();
   const tagSha = String(options.tagSha || '').trim();
@@ -14,6 +22,7 @@ function decidePublishPlan(options) {
   const published = normalizeBoolean(options.published);
   const tagExists = normalizeBoolean(options.tagExists);
   const tagMatchesCurrentCommit = tagExists && tagSha === currentSha;
+  const npmTag = getNpmTag(version);
 
   if (!version) {
     throw new Error('VERSION is required.');
@@ -51,6 +60,7 @@ function decidePublishPlan(options) {
       reason: `Version ${version} is new. Create tag v${version}, publish to npm, and create a GitHub Release.`,
       createTag: true,
       publishNpm: true,
+      npmTag,
       ensureRelease: true,
       skipPublish: false,
       tagMatchesCurrentCommit: false,
@@ -63,6 +73,7 @@ function decidePublishPlan(options) {
       reason: `Tag v${version} already points at ${currentSha}. Resume npm publish without recreating the tag.`,
       createTag: false,
       publishNpm: true,
+      npmTag,
       ensureRelease: true,
       skipPublish: false,
       tagMatchesCurrentCommit: true,
@@ -75,6 +86,7 @@ function decidePublishPlan(options) {
       reason: `Version ${version} is already published from the current commit ${currentSha}.`,
       createTag: false,
       publishNpm: false,
+      npmTag,
       ensureRelease: true,
       skipPublish: true,
       tagMatchesCurrentCommit: true,
@@ -86,6 +98,7 @@ function decidePublishPlan(options) {
     reason: `Version ${version} is already published from commit ${tagSha}. Skip npm publish for this merge because package version did not change.`,
     createTag: false,
     publishNpm: false,
+    npmTag,
     ensureRelease: false,
     skipPublish: true,
     tagMatchesCurrentCommit: false,
@@ -102,6 +115,7 @@ function writeGithubOutputs(plan, outputPath) {
     `reason=${plan.reason}`,
     `create_tag=${String(plan.createTag)}`,
     `publish_npm=${String(plan.publishNpm)}`,
+    `npm_tag=${plan.npmTag}`,
     `ensure_release=${String(plan.ensureRelease)}`,
     `skip_publish=${String(plan.skipPublish)}`,
     `tag_matches_current_commit=${String(plan.tagMatchesCurrentCommit)}`,
@@ -137,6 +151,8 @@ if (require.main === module) {
 
 module.exports = {
   decidePublishPlan,
+  getNpmTag,
+  isPrereleaseVersion,
   normalizeBoolean,
   runCli,
   writeGithubOutputs,

package/scripts/self-healing-check.js

@@ -8,10 +8,14 @@ const { appendDiagnosticRecord } = require('./feedback-loop');
 
 const PROJECT_ROOT = path.join(__dirname, '..');
 const DEFAULT_MAX_BUFFER_BYTES = 64 * 1024 * 1024;
+const DEFAULT_TESTS_TIMEOUT_MS = Number.parseInt(
+  process.env.THUMBGATE_SELF_HEAL_TEST_TIMEOUT_MS || '',
+  10,
+) || 60 * 60_000;
 
 const DEFAULT_CHECKS = [
   { name: 'budget_status', command: ['npm', 'run', 'budget:status'], timeoutMs: 60_000 },
-  { name: 'tests', command: ['npm', 'test'], timeoutMs: 15 * 60_000 },
+  { name: 'tests', command: ['npm', 'test'], timeoutMs: DEFAULT_TESTS_TIMEOUT_MS },
   { name: 'prove_adapters', command: ['npm', 'run', 'prove:adapters'], timeoutMs: 10 * 60_000, useTempProofDir: true },
   { name: 'prove_automation', command: ['npm', 'run', 'prove:automation'], timeoutMs: 10 * 60_000, useTempProofDir: true },
   { name: 'prove_data_pipeline', command: ['npm', 'run', 'prove:data-pipeline'], timeoutMs: 10 * 60_000, useTempProofDir: true },
@@ -177,6 +181,7 @@ function runCli() {
 
 module.exports = {
   DEFAULT_CHECKS,
+  DEFAULT_TESTS_TIMEOUT_MS,
   DEFAULT_MAX_BUFFER_BYTES,
   runCommand,
   collectHealthReport,