atris 3.70.0 → 3.71.1

package/lib/campaign-new.js

@@ -0,0 +1,251 @@
+// atris campaign new "<goal>": the owner's engine drafts a judge for the goal,
+// the CLI runs it to prove it fails today, shows the draft, and with --yes
+// starts the campaign. A judge is a script outside the model: exit 0 means the
+// goal is met. Asking goes through the read-only engine ask runner, the same
+// way the campaign loop asks the owner for missions.
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { newCampaignId } = require('./campaign-store');
+
+const DEFAULT_BUDGET = 20;
+const DEFAULT_OWNER = 'mission-lead';
+const DRAFT_TIMEOUT_SECONDS = 10 * 60;
+const ASK_TIMEOUT_MS = 5 * 60 * 1000;
+const ATTEMPTS = 2;
+const MAX_SEATS = 3;
+const MAX_SCRIPT_BYTES = 8 * 1024;
+
+function money(value) {
+  return `$${Number(value).toFixed(2)}`;
+}
+
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+
+// Members with a MEMBER.md can take a seat.
+function teamMembers(root) {
+  const dir = path.join(root, 'atris', 'team');
+  try {
+    return fs.readdirSync(dir, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory() && !entry.name.startsWith('_') && fs.existsSync(path.join(dir, entry.name, 'MEMBER.md')))
+      .map((entry) => entry.name)
+      .sort();
+  } catch {
+    return [];
+  }
+}
+
+// A few facts about the workspace so the judge uses commands that exist here.
+function workspaceHints(root) {
+  const lines = [];
+  try {
+    const entries = fs.readdirSync(root).filter((name) => !name.startsWith('.')).sort().slice(0, 30);
+    if (entries.length) lines.push(`Top-level files: ${entries.join(', ')}`);
+  } catch {}
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+    const scripts = Object.entries(pkg.scripts || {}).slice(0, 15).map(([name, cmd]) => `  npm run ${name}: ${String(cmd).slice(0, 120)}`);
+    if (scripts.length) lines.push('package.json scripts:', ...scripts);
+  } catch {}
+  return lines;
+}
+
+function judgePrompt({ goal, members, hints, previous }) {
+  return [
+    'You write the judge for a new Atris campaign. Answer with JSON only.',
+    '',
+    `Goal: ${goal}`,
+    ...hints,
+    members.length ? `Members who can work on it: ${members.join(', ')}` : '',
+    '',
+    'A judge is a POSIX sh script that runs from the workspace root. It exits 0 only when the goal is met.',
+    'Today the goal is not met, so today it must exit non-zero.',
+    'Rules:',
+    '- Check real outcomes outside any model: run tests, count files, grep output, run a local command. Never ask a model whether it is done.',
+    '- Print graded progress so a person sees how close it is: a line "ℹ pass N" and a line "ℹ fail M" (checks met, checks not met).',
+    '- Read and run only; change nothing. Finish in under two minutes. Use only commands that exist here.',
+    previous ? `Your last draft did not work: ${previous}. Write a different judge.` : '',
+    '',
+    'Reply with one JSON object and nothing else:',
+    `{"title": "<short name, under 60 characters>", "judge_script": "<the whole sh script>", "why": "<one sentence: what it checks and why it fails today>", "seats": ["<up to ${MAX_SEATS} members from the list who should work on this>"]}`,
+  ].filter((line) => line !== '').join('\n');
+}
+
+function parseDraft(text, members) {
+  const match = String(text || '').match(/\{[\s\S]*\}/);
+  if (!match) return null;
+  let row;
+  try {
+    row = JSON.parse(match[0]);
+  } catch {
+    return null;
+  }
+  if (!row || typeof row.judge_script !== 'string' || !row.judge_script.trim()) return null;
+  if (Buffer.byteLength(row.judge_script) > MAX_SCRIPT_BYTES) return null;
+  const known = new Set(members);
+  const seats = Array.isArray(row.seats) ? [...new Set(row.seats.filter((s) => typeof s === 'string' && known.has(s)))].slice(0, MAX_SEATS) : [];
+  return {
+    title: typeof row.title === 'string' && row.title.trim() ? row.title.trim().slice(0, 80) : '',
+    script: row.judge_script.trim(),
+    why: typeof row.why === 'string' ? row.why.trim().slice(0, 300) : '',
+    seats,
+  };
+}
+
+// The owner's engine through the read-only ask runner.
+async function askOwner(root, view, prompt) {
+  const { resolveEngineForMember } = require('./member-engine');
+  const { runEngineAskJobs } = require('./engine-ask');
+  const pick = resolveEngineForMember(view.owner, root) || {};
+  const engine = (pick.engine && pick.engine.id) || 'claude';
+  const [answer] = await runEngineAskJobs([{ engine, model: pick.model || '', prompt, label: 'campaign new judge' }], { root, timeoutMs: ASK_TIMEOUT_MS });
+  return { text: (answer && answer.stdout) || '', engine, ok: Boolean(answer && answer.ok) };
+}
+
+function writeJudge(root, id, script) {
+  const rel = path.join('atris', 'campaigns', id, 'judge.sh');
+  const file = path.join(root, rel);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const body = script.startsWith('#!') ? script : `#!/bin/sh\n${script}`;
+  fs.writeFileSync(file, body.endsWith('\n') ? body : `${body}\n`, { mode: 0o755 });
+  return rel.split(path.sep).join('/');
+}
+
+// 126 and 127 mean the shell could not run a command; null means it hung or
+// never started. Those are broken judges, not failing ones.
+function brokenReading(reading) {
+  return reading.exit === null || reading.exit === undefined || reading.exit === 126 || reading.exit === 127;
+}
+
+// Ask, write, run; one retry with the reason when the draft passes today,
+// cannot run, or is not a script.
+async function draftJudge({ root, goal, owner, idFlag, timeout, ask, judge }) {
+  const members = teamMembers(root);
+  const hints = workspaceHints(root);
+  let previous = '';
+  let id = idFlag || '';
+  let last = null;
+  for (let attempt = 1; attempt <= ATTEMPTS; attempt++) {
+    const prompt = judgePrompt({ goal, members, hints, previous });
+    const answer = await ask(root, { id: id || 'new', owner, title: goal }, prompt);
+    const draft = parseDraft(answer.text, members);
+    if (!draft) {
+      previous = 'the reply was not one JSON object with a judge_script';
+      last = { error: `${owner}'s engine (${answer.engine || 'unknown'}) did not return a judge script` };
+      continue;
+    }
+    if (!draft.title) draft.title = goal.slice(0, 80);
+    if (!id) id = newCampaignId(draft.title);
+    const judgeFile = writeJudge(root, id, draft.script);
+    const command = `sh ${judgeFile}`;
+    const reading = await judge(command, timeout);
+    const result = { id, draft, judgeFile, command, reading, engine: answer.engine };
+    if (reading.passed) {
+      previous = `it passed today (${reading.summary || 'exit 0'}), so it cannot tell when the goal is met`;
+      last = { ...result, error: `the drafted judge already passes (${reading.summary || 'exit 0'}); a judge must fail first` };
+      continue;
+    }
+    if (brokenReading(reading)) {
+      previous = `it could not run (${reading.summary || `exit ${reading.exit}`})`;
+      last = { ...result, error: `the drafted judge could not run: ${reading.summary || `exit ${reading.exit}`}` };
+      continue;
+    }
+    return { ok: true, ...result };
+  }
+  if (id && !idFlag) fs.rmSync(path.join(root, 'atris', 'campaigns', id), { recursive: true, force: true });
+  return { ok: false, ...last };
+}
+
+function startArgs(result, { budget, owner, run }) {
+  const args = ['start', result.draft.title, '--judge', result.command, '--budget', String(budget), '--id', result.id, '--owner', owner];
+  for (const seat of result.draft.seats) args.push('--seat', seat);
+  if (run) args.push('--run');
+  return args;
+}
+
+function startCommand(result, options) {
+  const seats = result.draft.seats.map((seat) => ` --seat ${seat}`).join('');
+  return `atris campaign start ${shellQuote(result.draft.title)} --judge ${shellQuote(result.command)} --budget ${options.budget} --id ${result.id} --owner ${options.owner}${seats}`;
+}
+
+function renderDraft(result, options) {
+  const lines = [
+    `draft for: ${options.goal}`,
+    '',
+    `title     ${result.draft.title}`,
+    `judge     ${result.command}`,
+    `today     fails, as it should: ${result.reading.summary || `exit ${result.reading.exit}`}`,
+  ];
+  if (result.draft.why) lines.push(`checks    ${result.draft.why}`);
+  lines.push(`owner     ${options.owner}`);
+  lines.push(`seats     ${result.draft.seats.length ? result.draft.seats.join(', ') : 'none yet'}`);
+  lines.push(`budget    ${money(options.budget)}`);
+  lines.push('', `read or edit the judge: ${result.judgeFile}`);
+  return lines.join('\n');
+}
+
+function askAtTerminal(question) {
+  if (!process.stdin.isTTY || !process.stderr.isTTY) return Promise.resolve(false);
+  const readline = require('readline');
+  const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve) => rl.question(question, (answer) => {
+    rl.close();
+    resolve(/^y(es)?$/i.test(answer.trim()));
+  }));
+}
+
+// deps.start is the start verb; deps.ask replaces the owner's engine in tests.
+async function draftAndStart(args, ctx, deps = {}) {
+  const { readFlag } = require('./arg-parser');
+  const goal = String(deps.goal || '').trim();
+  if (!goal) return ctx.fail('say the goal: atris campaign new "<goal>" [--budget 20] [--owner <member>] [--yes] [--run]');
+  const budgetText = readFlag(args, '--budget', '');
+  const budget = budgetText ? Number(budgetText) : DEFAULT_BUDGET;
+  if (!(budget > 0)) return ctx.fail('--budget must be dollars above 0');
+  const owner = readFlag(args, '--owner', '') || DEFAULT_OWNER;
+  const timeout = Number(readFlag(args, '--timeout', '')) || DRAFT_TIMEOUT_SECONDS;
+  const options = { goal, budget, owner, run: args.includes('--run') };
+  if (!ctx.asJson) console.error(`asking ${owner}'s engine to draft a judge that fails today`);
+
+  const result = await draftJudge({
+    root: deps.root || process.cwd(), goal, owner, timeout,
+    idFlag: readFlag(args, '--id', ''),
+    ask: deps.ask || askOwner,
+    judge: ctx.judge,
+  });
+  if (!result.ok) {
+    if (ctx.asJson) {
+      console.log(JSON.stringify({ ok: false, error: result.error, draft: result.draft || null, reading: result.reading || null }));
+      return 1;
+    }
+    return ctx.fail(`${result.error}. Write the judge yourself: atris campaign start "<title>" --judge "<command that fails today>" --budget ${budget}`, 1);
+  }
+
+  const draft = { id: result.id, title: result.draft.title, judge: result.command, judge_file: result.judgeFile, why: result.draft.why, seats: result.draft.seats, owner, budget, engine: result.engine };
+  // Only a person at a terminal can say yes here; agents and pipes pass --yes.
+  const confirm = deps.confirm || askAtTerminal;
+  const canAsk = deps.confirm ? true : Boolean(process.stdin.isTTY && process.stderr.isTTY);
+  const asked = !args.includes('--yes') && !ctx.asJson && canAsk;
+  const yes = args.includes('--yes') || (asked && await confirm(`${renderDraft(result, options)}\n\nstart it${options.run ? ' and run it' : ''}? [y/N] `));
+  if (!yes) {
+    const command = startCommand(result, options);
+    const shown = asked ? 'not started.' : renderDraft(result, options);
+    ctx.out(`${shown}\nstart it:  ${command}\n(or run this again with --yes)`,
+      { ok: true, action: 'campaign_drafted', draft, reading: result.reading, start_command: command });
+    return 0;
+  }
+  // Start with the reading already taken, so the judge does not run twice.
+  if (!ctx.asJson && args.includes('--yes')) console.log(renderDraft(result, options));
+  const startCtx = {
+    ...ctx,
+    judge: async () => result.reading,
+    out: (human, json) => ctx.out(human, { ...json, draft }),
+  };
+  return deps.start(startArgs(result, options), startCtx);
+}
+
+module.exports = { draftAndStart, judgePrompt, parseDraft };

package/lib/campaign-protect.js

@@ -0,0 +1,75 @@
+// Protected paths: files a campaign's agents must not touch, like the judge's
+// questions. Start saves the paths and the commit they started from in the
+// campaign folder beside the campaign store, outside the checkout, so agents
+// cannot edit the list; guard names any of them changed since, committed or not.
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+function git(root, args) {
+  const result = spawnSync('git', args, { cwd: root, encoding: 'utf8' });
+  return { ok: result.status === 0, out: (result.stdout || '').trim(), err: (result.stderr || '').trim() };
+}
+
+function checkoutTop(root) {
+  const top = git(root, ['rev-parse', '--show-toplevel']);
+  return top.ok ? fs.realpathSync(top.out) : null;
+}
+
+// The folder holding every campaign's own files, beside the campaign store.
+function campaignHome(store) {
+  const { campaignDbPath } = require('./campaign-store');
+  return path.dirname((store && store.path) || campaignDbPath());
+}
+
+function protectFile(home, campaignId) {
+  return path.join(home, 'campaigns', campaignId, 'protect.json');
+}
+
+// The commit and checkout-relative paths to save, or an error in plain words.
+function planProtect(root, paths) {
+  const topDir = checkoutTop(root);
+  if (!topDir) return { error: '--protect needs a git checkout' };
+  const head = git(root, ['rev-parse', 'HEAD']);
+  if (!head.ok) return { error: '--protect needs a checkout with at least one commit' };
+  const here = fs.realpathSync(root);
+  const rels = [];
+  for (const given of paths) {
+    const rel = path.relative(topDir, path.resolve(here, given)).split(path.sep).join('/');
+    if (!rel || rel.startsWith('..') || path.isAbsolute(rel)) return { error: `--protect ${given} is not inside this checkout` };
+    if (!rels.includes(rel)) rels.push(rel);
+  }
+  return { paths: rels, base_commit: head.out };
+}
+
+function saveProtect(home, campaignId, plan) {
+  const file = protectFile(home, campaignId);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify({ paths: plan.paths, base_commit: plan.base_commit }, null, 2)}\n`);
+  return file;
+}
+
+function readProtect(home, campaignId) {
+  try {
+    return JSON.parse(fs.readFileSync(protectFile(home, campaignId), 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+// Protected paths that differ from the base commit: committed, staged,
+// unstaged, deleted, or new and untracked. Root is the checkout top, since
+// the saved paths are relative to it.
+function changedProtected(root, saved) {
+  const spec = ['--', ...saved.paths.map((rel) => `:(top,literal)${rel}`)];
+  const diff = git(root, ['diff', '--name-only', saved.base_commit, ...spec]);
+  if (!diff.ok) return { error: `cannot compare with ${String(saved.base_commit).slice(0, 12)}: ${diff.err || 'git diff failed'}` };
+  const untracked = git(root, ['ls-files', '--others', '--exclude-standard', '--full-name', ...spec]);
+  const changed = [...diff.out.split('\n'), ...untracked.out.split('\n')].filter(Boolean);
+  return { changed: [...new Set(changed)].sort() };
+}
+
+module.exports = { campaignHome, changedProtected, checkoutTop, planProtect, protectFile, readProtect, saveProtect };

package/lib/campaign-reading.js

@@ -0,0 +1,147 @@
+// Graded judge readings: a number from 0 to 1 pulled from a judge's output,
+// so a campaign learns "3 of 5 tests pass" instead of only "failed". Pure, no
+// I/O. The reading rides on judge_ran as data.reading (lib/campaign-schema.js
+// already allows it); traces use it as the reward signal
+// (atris/features/campaign/traces.md).
+//
+// Formats, first match wins:
+//   reading: 0.6                       a judge that states its own reading
+//   3 of 5 live  /  3/5 ok             the judge's final line
+//   node --test   ℹ pass 3 / ℹ fail 2  (also TAP "# pass 3", and "pass 3, fail 2")
+//   jest/vitest   Tests: 1 failed, 4 passed, 5 total  /  Tests  1 failed | 4 passed (5)
+//   pytest        1 failed, 4 passed in 0.12s
+//   mocha         4 passing / 1 failing
+// Output with no counts gives null: a reading is never invented.
+
+'use strict';
+
+function round(value) {
+  return Math.round(Math.min(1, Math.max(0, value)) * 10000) / 10000;
+}
+
+function ratio(good, total) {
+  return total > 0 ? round(good / total) : null;
+}
+
+function count(line, word) {
+  const match = line.match(new RegExp(`(\\d+)\\s+${word}\\b`, 'i'));
+  return match ? Number(match[1]) : 0;
+}
+
+function stated(lines) {
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const match = lines[i].match(/^reading\s*[:=]\s*(\d*\.?\d+)\s*$/i);
+    if (match) return round(Number(match[1]));
+  }
+  return null;
+}
+
+function finalOf(lines) {
+  const last = lines[lines.length - 1] || '';
+  const match = last.match(/^(\d+)\s*(?:of|\/)\s*(\d+)\b/i);
+  if (!match || Number(match[1]) > Number(match[2])) return null;
+  return ratio(Number(match[1]), Number(match[2]));
+}
+
+// node --test prints one summary block per run; a judge that chains runs
+// (a && b) gets the sum of every block.
+function nodeCounts(text) {
+  const tokens = /(?:^|,)[ \t]*(?:ℹ|#)?[ \t]*(pass|fail|cancelled)[ \t]+(\d+)[ \t]*(?=,|$)/gim;
+  const sums = { pass: 0, fail: 0, cancelled: 0 };
+  let seen = false;
+  for (const match of text.matchAll(tokens)) {
+    sums[match[1].toLowerCase()] += Number(match[2]);
+    seen = true;
+  }
+  return seen ? ratio(sums.pass, sums.pass + sums.fail + sums.cancelled) : null;
+}
+
+function lastLine(lines, pattern) {
+  for (let i = lines.length - 1; i >= 0; i--) if (pattern.test(lines[i])) return lines[i];
+  return null;
+}
+
+function jestCounts(lines) {
+  const line = lastLine(lines, /^Tests:?\s+.*\d+\s+(passed|failed)/i);
+  if (!line) return null;
+  return ratio(count(line, 'passed'), count(line, 'passed') + count(line, 'failed'));
+}
+
+function pytestCounts(lines) {
+  const line = lastLine(lines, /\d+\s+(passed|failed)\b/i);
+  if (!line) return null;
+  const errors = count(line, 'errors') || count(line, 'error');
+  return ratio(count(line, 'passed'), count(line, 'passed') + count(line, 'failed') + errors);
+}
+
+function mochaCounts(lines) {
+  const passing = lastLine(lines, /^\d+\s+passing\b/i);
+  if (!passing) return null;
+  const failing = lastLine(lines, /^\d+\s+failing\b/i);
+  const good = count(passing, 'passing');
+  return ratio(good, good + (failing ? count(failing, 'failing') : 0));
+}
+
+// The reading in [0, 1], or null when the output has no counts.
+function judgeReading(output) {
+  const text = String(output || '').replace(/\r/g, '');
+  // Strip color codes so a colored reporter reads the same as a piped one.
+  const plain = text.replace(/\x1b\[[0-9;]*m/g, '');
+  const lines = plain.split('\n').map((line) => line.trim()).filter(Boolean);
+  if (!lines.length) return null;
+  for (const read of [stated, finalOf]) {
+    const value = read(lines);
+    if (value !== null) return value;
+  }
+  const node = nodeCounts(lines.join('\n'));
+  if (node !== null) return node;
+  for (const read of [jestCounts, pytestCounts, mochaCounts]) {
+    const value = read(lines);
+    if (value !== null) return value;
+  }
+  return null;
+}
+
+const TAIL_LINES = 40;
+const TAIL_BYTES = 4096;
+
+// The end of the judge's output, so the planner sees more than one line:
+// the last 40 lines, at most 4 KB, color codes removed.
+function outputTail(output) {
+  const lines = String(output || '').replace(/\r/g, '').replace(/\x1b\[[0-9;]*m/g, '').split('\n');
+  while (lines.length && !lines[lines.length - 1].trim()) lines.pop();
+  let tail = lines.slice(-TAIL_LINES).join('\n');
+  const bytes = Buffer.from(tail, 'utf8');
+  if (bytes.length > TAIL_BYTES) {
+    // Cut on a character boundary: drop continuation bytes at the cut.
+    let start = bytes.length - TAIL_BYTES;
+    while (start < bytes.length && (bytes[start] & 0xc0) === 0x80) start++;
+    tail = bytes.subarray(start).toString('utf8');
+  }
+  return tail;
+}
+
+// The data a judge_ran event carries for one run of the judge command.
+// A judge that prints no pass/fail counts still said something; its last line
+// beats a bare exit code.
+function lastSaidLine(text) {
+  const lines = String(text || '').split('\n').map((line) => line.trim()).filter(Boolean);
+  return lines.length ? lines[lines.length - 1].slice(0, 200) : '';
+}
+
+function judgeRanData(result) {
+  const data = { passed: result.passed, summary: result.summary || lastSaidLine(result.output_tail) || `exit ${result.exit}`, seconds: result.seconds };
+  if (typeof result.reading === 'number' && Number.isFinite(result.reading)) data.reading = result.reading;
+  if (typeof result.output_tail === 'string' && result.output_tail) data.output_tail = result.output_tail;
+  return data;
+}
+
+// The output_tail of the latest judge run in fold order, or null.
+function latestJudgeOutput(events) {
+  const { compareEvents } = require('./campaign-core');
+  const runs = (events || []).filter((e) => e.type === 'judge_ran').sort(compareEvents);
+  const last = runs[runs.length - 1];
+  return last && typeof last.data.output_tail === 'string' && last.data.output_tail ? last.data.output_tail : null;
+}
+
+module.exports = { judgeReading, judgeRanData, latestJudgeOutput, outputTail };

package/lib/campaign-run-lock.js

@@ -0,0 +1,59 @@
+'use strict';
+
+// One driver per campaign on a computer. Two `campaign run` loops on the same
+// campaign each planned and started missions, so they raced for the same
+// budget and edited the same files (2026-10-15, cmp-suite-3min). The lock is
+// a file beside the store naming the process that holds it; a lock whose
+// process is gone is stale and is taken over.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+function lockPath(home, campaignId) {
+  return path.join(home, 'campaigns', campaignId, 'run.lock');
+}
+
+function alive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === 'EPERM';
+  }
+}
+
+function readHolder(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+// Returns { ok: true, release } or { ok: false, holder } when a live run holds it.
+function acquireRunLock(home, campaignId, { pid = process.pid, host = os.hostname(), cwd = process.cwd(), isAlive = alive } = {}) {
+  const file = lockPath(home, campaignId);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const mine = { pid, host, cwd, started_at: new Date().toISOString() };
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      fs.writeFileSync(file, `${JSON.stringify(mine)}\n`, { flag: 'wx' });
+      const release = () => {
+        const holder = readHolder(file);
+        if (holder && holder.pid === pid && holder.host === host) fs.rmSync(file, { force: true });
+      };
+      return { ok: true, release };
+    } catch (error) {
+      if (error.code !== 'EEXIST') throw error;
+    }
+    const holder = readHolder(file);
+    if (holder && holder.host === host && isAlive(holder.pid)) return { ok: false, holder };
+    if (holder && holder.host !== host) return { ok: false, holder };
+    fs.rmSync(file, { force: true });
+  }
+  return { ok: false, holder: readHolder(file) };
+}
+
+module.exports = { acquireRunLock, lockPath };