synergyspec-selfevolving 2.1.5 → 2.1.6

package/dist/core/runner-evidence.js

@@ -0,0 +1,613 @@
+import { createHash } from 'crypto';
+import { promises as fs } from 'fs';
+import path from 'path';
+import { parseTestMetrics, parseTestCollection, } from './fitness/test-metrics.js';
+import { parseTestFailures } from './fitness/test-failures.js';
+const RUNNER_EXIT_JSON_PATTERN = /`([^`\r\n]*runner-exit\.json)`|([^\s|`]+runner-exit\.json)/gi;
+export async function readRunnerEvidenceFromTestReport(args) {
+    return (await readRunnerEvidenceResultFromTestReport(args)).evidence;
+}
+export async function readRunnerEvidenceResultFromTestReport(args) {
+    const projectRoot = path.resolve(args.projectRoot);
+    const changeDir = args.changeDir ? path.resolve(args.changeDir) : undefined;
+    const exitJsonPath = (await extractRunnerExitJsonPath(args.testReportContent, projectRoot, changeDir)) ??
+        (await findLatestRunnerExitJsonPath(projectRoot, args.changeName, changeDir));
+    if (!exitJsonPath)
+        return { evidence: null, reason: 'runner-exit.json not found' };
+    let rawExit;
+    try {
+        rawExit = await fs.readFile(exitJsonPath, 'utf-8');
+    }
+    catch (err) {
+        return {
+            evidence: null,
+            exitJsonPath,
+            reason: `runner-exit.json unreadable: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(rawExit);
+    }
+    catch (err) {
+        return {
+            evidence: null,
+            exitJsonPath,
+            reason: `runner-exit.json is malformed: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+    const record = asRecord(parsed);
+    if (!record) {
+        return {
+            evidence: null,
+            exitJsonPath,
+            reason: 'runner-exit.json root must be an object',
+        };
+    }
+    const current = await readCurrentWorkspaceIdentity(projectRoot, args.changeName);
+    const workspaceIdentity = validateWorkspaceIdentity(projectRoot, args.changeName, record.workspaceIdentity, current);
+    if (!workspaceIdentity.verified) {
+        const evidence = {
+            exitJsonPath,
+            exitCode: numberOrNull(record.exitCode),
+            testMetrics: null,
+            outputText: '',
+            sourcePaths: [exitJsonPath],
+            workspaceIdentity,
+        };
+        return { evidence, exitJsonPath, reason: workspaceIdentity.reason };
+    }
+    const recordProblem = await validateRunnerEvidenceRecord(projectRoot, changeDir, record, exitJsonPath);
+    if (recordProblem) {
+        return {
+            evidence: null,
+            exitJsonPath,
+            reason: recordProblem,
+        };
+    }
+    const stdoutLogPath = await resolveEvidencePath(projectRoot, changeDir, stringOrUndefined(record.stdoutLog));
+    const stderrLogPath = await resolveEvidencePath(projectRoot, changeDir, stringOrUndefined(record.stderrLog));
+    const exitCode = numberOrNull(record.exitCode);
+    const command = stringOrUndefined(record.command);
+    const [stdout, stderr] = await Promise.all([
+        readOptionalText(stdoutLogPath),
+        readOptionalText(stderrLogPath),
+    ]);
+    const outputText = [stdout, stderr].filter((text) => text.length > 0).join('\n');
+    const parsedMetrics = structuredTestMetrics(record.testMetrics) ?? parseTestMetrics(outputText);
+    const testMetrics = metricsWithExitCodeSignal(parsedMetrics, exitCode);
+    const sourcePaths = [
+        exitJsonPath,
+        ...(stdoutLogPath ? [stdoutLogPath] : []),
+        ...(stderrLogPath ? [stderrLogPath] : []),
+    ];
+    return {
+        evidence: {
+            exitJsonPath,
+            ...(command ? { command } : {}),
+            ...(stdoutLogPath ? { stdoutLogPath } : {}),
+            ...(stderrLogPath ? { stderrLogPath } : {}),
+            exitCode,
+            testMetrics,
+            outputText,
+            sourcePaths,
+            workspaceIdentity,
+        },
+        exitJsonPath,
+    };
+}
+export function runnerEvidenceToTrajectoryFacts(args) {
+    const { evidence } = args;
+    if (!evidence.workspaceIdentity.verified)
+        return null;
+    const observedPassRate = evidence.testMetrics?.passRate ?? null;
+    const runnerExitCode = evidence.exitCode;
+    let observedStatus = null;
+    const failed = (runnerExitCode !== null && runnerExitCode > 0) ||
+        (observedPassRate !== null && observedPassRate < 1);
+    const passed = (runnerExitCode === 0 || runnerExitCode === null) &&
+        observedPassRate !== null &&
+        observedPassRate >= 1;
+    observedStatus = failed ? 'failure' : passed ? 'success' : null;
+    const expected = (args.expectedTestPaths ?? []).map(normPath).filter(Boolean);
+    const changeScope = changeScopeVerdict(evidence.outputText, expected, evidence.command);
+    let scopeDemoted = false;
+    if (changeScope === 'out-of-scope' && observedStatus === 'success') {
+        observedStatus = null;
+        scopeDemoted = true;
+    }
+    const observedFailures = evidence.outputText ? parseTestFailures(evidence.outputText) : [];
+    return {
+        harness: 'runner-evidence',
+        changeName: args.changeName,
+        testRunObserved: true,
+        runnerExitCode,
+        observedPassRate,
+        observedStatus,
+        verified: observedStatus !== null,
+        ...(observedFailures.length > 0 ? { observedFailures } : {}),
+        ...(changeScope !== undefined ? { changeScope } : {}),
+        ...(scopeDemoted ? { scopeDemoted: true } : {}),
+        toolCallCount: 1,
+        subagentCount: 0,
+        sourcePaths: evidence.sourcePaths,
+    };
+}
+async function extractRunnerExitJsonPath(report, projectRoot, changeDir) {
+    RUNNER_EXIT_JSON_PATTERN.lastIndex = 0;
+    let latest = null;
+    for (const match of report.matchAll(RUNNER_EXIT_JSON_PATTERN)) {
+        const value = (match[1] ?? match[2] ?? '').trim();
+        if (!value)
+            continue;
+        const withoutMdLink = value.replace(/^\((.*)\)$/, '$1');
+        latest = {
+            direct: resolveProjectPath(projectRoot, withoutMdLink),
+            remapped: resolveChangeDirTestEvidencePath(projectRoot, changeDir, withoutMdLink),
+        };
+    }
+    if (!latest)
+        return null;
+    if (latest.direct && (await fileExists(latest.direct)))
+        return latest.direct;
+    if (latest.remapped && (await fileExists(latest.remapped)))
+        return latest.remapped;
+    return latest.direct ?? latest.remapped;
+}
+async function findLatestRunnerExitJsonPath(projectRoot, changeName, changeDir) {
+    const evidenceRoot = changeDir
+        ? path.join(changeDir, 'test-evidence')
+        : path.join(projectRoot, 'synergyspec-selfevolving', 'changes', changeName, 'test-evidence');
+    let entries;
+    try {
+        entries = await fs.readdir(evidenceRoot);
+    }
+    catch {
+        return null;
+    }
+    const candidates = (await Promise.all(entries.map(async (entry) => {
+        const candidate = path.join(evidenceRoot, entry, 'runner-exit.json');
+        try {
+            const st = await fs.stat(candidate);
+            return st.isFile() ? { file: candidate, mtimeMs: st.mtimeMs } : null;
+        }
+        catch {
+            return null;
+        }
+    })))
+        .filter((entry) => entry !== null)
+        .sort((left, right) => right.mtimeMs - left.mtimeMs || right.file.localeCompare(left.file));
+    return candidates[0]?.file ?? null;
+}
+function resolveChangeDirTestEvidencePath(projectRoot, changeDir, rawPath) {
+    if (!changeDir || path.isAbsolute(rawPath))
+        return null;
+    const normalized = rawPath.replace(/\\/g, '/');
+    const marker = '/test-evidence/';
+    const markerIndex = normalized.indexOf(marker);
+    const bareMarkerIndex = normalized.startsWith('test-evidence/') ? 0 : -1;
+    const suffix = markerIndex >= 0
+        ? normalized.slice(markerIndex + marker.length)
+        : bareMarkerIndex === 0
+            ? normalized.slice('test-evidence/'.length)
+            : null;
+    if (!suffix)
+        return null;
+    const resolved = path.resolve(changeDir, 'test-evidence', ...suffix.split('/'));
+    return isInside(projectRoot, resolved) && isInside(changeDir, resolved) ? resolved : null;
+}
+function resolveProjectPath(projectRoot, rawPath) {
+    if (!rawPath)
+        return null;
+    const resolved = path.isAbsolute(rawPath)
+        ? path.normalize(rawPath)
+        : path.resolve(projectRoot, rawPath);
+    if (!isInside(projectRoot, resolved))
+        return null;
+    return resolved;
+}
+async function validateRunnerEvidenceRecord(projectRoot, changeDir, record, exitJsonPath) {
+    if (!isInside(projectRoot, exitJsonPath)) {
+        return `runner-exit.json is outside project root: ${exitJsonPath}`;
+    }
+    if (!stringOrUndefined(record.command))
+        return 'runner-exit.json command is missing or invalid';
+    const cwd = stringOrUndefined(record.cwd);
+    if (!cwd)
+        return 'runner-exit.json cwd is missing or invalid';
+    if (!sameResolvedPath(cwd, projectRoot)) {
+        return `runner cwd changed from ${cwd} to ${path.resolve(projectRoot)}`;
+    }
+    if (!stringOrUndefined(record.startedAt))
+        return 'runner-exit.json startedAt is missing or invalid';
+    if (!stringOrUndefined(record.finishedAt))
+        return 'runner-exit.json finishedAt is missing or invalid';
+    if (typeof record.exitCode !== 'number' || !Number.isInteger(record.exitCode)) {
+        return 'runner-exit.json exitCode is missing or invalid';
+    }
+    const stdoutLog = stringOrUndefined(record.stdoutLog);
+    const stderrLog = stringOrUndefined(record.stderrLog);
+    if (!stdoutLog)
+        return 'runner-exit.json stdoutLog is missing or invalid';
+    if (!stderrLog)
+        return 'runner-exit.json stderrLog is missing or invalid';
+    const requiredPathProblem = (await validateEvidencePath(projectRoot, changeDir, stdoutLog, 'stdoutLog')) ??
+        (await validateEvidencePath(projectRoot, changeDir, stderrLog, 'stderrLog')) ??
+        (await validateEvidenceHash(projectRoot, changeDir, stdoutLog, record.stdoutLogSha256, 'stdoutLogSha256')) ??
+        (await validateEvidenceHash(projectRoot, changeDir, stderrLog, record.stderrLogSha256, 'stderrLogSha256'));
+    if (requiredPathProblem)
+        return requiredPathProblem;
+    for (const field of ['junitXml', 'coverageSummary', 'coverageLcov', 'coverageHtml']) {
+        const value = record[field];
+        if (value === null || value === undefined)
+            continue;
+        const pathValue = stringOrUndefined(value);
+        if (!pathValue)
+            return `runner-exit.json ${field} must be a path string or null`;
+        const problem = await validateEvidencePath(projectRoot, changeDir, pathValue, field);
+        if (problem)
+            return problem;
+    }
+    return null;
+}
+async function validateEvidencePath(projectRoot, changeDir, rawPath, field) {
+    const fullPath = await resolveEvidencePath(projectRoot, changeDir, rawPath);
+    if (!fullPath)
+        return `runner-exit.json ${field} points outside project root`;
+    try {
+        await fs.access(fullPath);
+    }
+    catch {
+        return `runner-exit.json ${field} is missing: ${formatProjectPath(projectRoot, fullPath)}`;
+    }
+    return null;
+}
+async function validateEvidenceHash(projectRoot, changeDir, rawPath, rawExpected, field) {
+    const expected = stringOrUndefined(rawExpected);
+    if (!expected)
+        return `runner-exit.json ${field} is missing or invalid`;
+    const fullPath = await resolveEvidencePath(projectRoot, changeDir, rawPath);
+    if (!fullPath)
+        return `runner-exit.json ${field} path points outside project root`;
+    let content;
+    try {
+        content = await fs.readFile(fullPath);
+    }
+    catch {
+        return `runner-exit.json ${field} cannot hash missing evidence: ${formatProjectPath(projectRoot, fullPath)}`;
+    }
+    const actual = createHash('sha256').update(content).digest('hex');
+    if (actual !== expected)
+        return `runner-exit.json ${field} does not match current log content`;
+    return null;
+}
+async function resolveEvidencePath(projectRoot, changeDir, rawPath) {
+    if (!rawPath)
+        return null;
+    const direct = resolveProjectPath(projectRoot, rawPath);
+    if (direct && (await fileExists(direct)))
+        return direct;
+    const remapped = resolveChangeDirTestEvidencePath(projectRoot, changeDir, rawPath);
+    if (remapped && (await fileExists(remapped)))
+        return remapped;
+    return direct ?? remapped;
+}
+function validateWorkspaceIdentity(projectRoot, changeName, value, current) {
+    const record = asRecord(value);
+    if (!record) {
+        return {
+            verified: false,
+            reason: 'runner-exit.json workspaceIdentity is missing or invalid',
+            current,
+        };
+    }
+    const recorded = workspaceIdentitySnapshotFromRecord(record);
+    const completenessProblems = validateWorkspaceIdentityCompleteness(recorded, current);
+    if (completenessProblems.length > 0) {
+        return {
+            verified: false,
+            reason: `runner-exit.json workspaceIdentity is incomplete: ${completenessProblems.join('; ')}`,
+            recorded,
+            current,
+        };
+    }
+    const mismatches = compareWorkspaceIdentities(projectRoot, changeName, recorded, current);
+    if (mismatches.length > 0) {
+        return {
+            verified: false,
+            reason: mismatches.join('; '),
+            recorded,
+            current,
+        };
+    }
+    return {
+        verified: true,
+        reason: 'current workspace package identity matches runner evidence',
+        recorded,
+        current,
+    };
+}
+async function readCurrentWorkspaceIdentity(projectRoot, changeName) {
+    return {
+        cwd: path.resolve(projectRoot),
+        changeName,
+        pyproject: await readPyprojectIdentity(projectRoot),
+        packageJson: await readPackageJsonIdentity(projectRoot),
+    };
+}
+async function readPyprojectIdentity(projectRoot) {
+    const filePath = path.join(projectRoot, 'pyproject.toml');
+    let content;
+    try {
+        content = await fs.readFile(filePath, 'utf-8');
+    }
+    catch {
+        return undefined;
+    }
+    return {
+        path: 'pyproject.toml',
+        name: parsePyprojectProjectName(content),
+        sha256: sha256(content),
+    };
+}
+async function readPackageJsonIdentity(projectRoot) {
+    const filePath = path.join(projectRoot, 'package.json');
+    let content;
+    try {
+        content = await fs.readFile(filePath, 'utf-8');
+    }
+    catch {
+        return undefined;
+    }
+    let name;
+    try {
+        const parsed = JSON.parse(content);
+        name = typeof parsed.name === 'string' ? parsed.name : undefined;
+    }
+    catch {
+        name = undefined;
+    }
+    return {
+        path: 'package.json',
+        name,
+        sha256: sha256(content),
+    };
+}
+function workspaceIdentitySnapshotFromRecord(record) {
+    return {
+        cwd: stringOrUndefined(record.cwd),
+        changeName: stringOrUndefined(record.changeName),
+        taskId: stringOrUndefined(record.taskId),
+        pyproject: fileSnapshotFromUnknown(record.pyproject),
+        packageJson: fileSnapshotFromUnknown(record.packageJson),
+    };
+}
+function fileSnapshotFromUnknown(value) {
+    const record = asRecord(value);
+    if (!record)
+        return undefined;
+    const snapshot = {};
+    const snapshotPath = stringOrUndefined(record.path);
+    const name = stringOrUndefined(record.name);
+    const hash = stringOrUndefined(record.sha256);
+    if (snapshotPath)
+        snapshot.path = snapshotPath;
+    if (name)
+        snapshot.name = name;
+    if (hash)
+        snapshot.sha256 = hash;
+    return Object.keys(snapshot).length > 0 ? snapshot : undefined;
+}
+function compareWorkspaceIdentities(projectRoot, changeName, recorded, current) {
+    const mismatches = [];
+    if (recorded.changeName && !changeNamesEquivalent(recorded.changeName, changeName)) {
+        mismatches.push(`change name changed from ${recorded.changeName} to ${changeName}`);
+    }
+    if (recorded.cwd && !sameResolvedPath(recorded.cwd, projectRoot)) {
+        mismatches.push(`runner cwd changed from ${recorded.cwd} to ${path.resolve(projectRoot)}`);
+    }
+    compareIdentityFile('pyproject.toml', recorded.pyproject, current.pyproject, mismatches);
+    compareIdentityFile('package.json', recorded.packageJson, current.packageJson, mismatches);
+    return mismatches;
+}
+function validateWorkspaceIdentityCompleteness(recorded, current) {
+    const problems = [];
+    if (!recorded.cwd)
+        problems.push('cwd is missing');
+    if (!recorded.changeName)
+        problems.push('changeName is missing');
+    const currentFiles = [
+        ['pyproject', 'pyproject.toml', current.pyproject],
+        ['packageJson', 'package.json', current.packageJson],
+    ];
+    for (const [key, label, currentFile] of currentFiles) {
+        if (!currentFile)
+            continue;
+        const recordedFile = recorded[key];
+        if (!recordedFile) {
+            problems.push(`${label} identity is missing`);
+            continue;
+        }
+        if (!recordedFile.path)
+            problems.push(`${label} path is missing`);
+        if (currentFile.name && !recordedFile.name)
+            problems.push(`${label} name is missing`);
+        if (!recordedFile.sha256)
+            problems.push(`${label} sha256 is missing`);
+    }
+    return problems;
+}
+function changeNamesEquivalent(recorded, current) {
+    if (recorded === current)
+        return true;
+    const archived = current.match(/^\d{4}-\d{2}-\d{2}-(.+)$/);
+    return archived?.[1] === recorded;
+}
+function compareIdentityFile(label, recorded, current, mismatches) {
+    if (!recorded)
+        return;
+    if (!current) {
+        mismatches.push(`${label} was present in runner evidence but is absent now`);
+        return;
+    }
+    if (recorded.name && current.name && recorded.name !== current.name) {
+        mismatches.push(`${label} name changed from ${recorded.name} to ${current.name}`);
+    }
+    else if (recorded.name && !current.name) {
+        mismatches.push(`${label} no longer exposes package name ${recorded.name}`);
+    }
+    if (recorded.sha256 && current.sha256 && recorded.sha256 !== current.sha256) {
+        mismatches.push(`${label} content changed since runner evidence was captured`);
+    }
+}
+function structuredTestMetrics(value) {
+    const record = asRecord(value);
+    if (!record)
+        return null;
+    const total = numberOrNull(record.total);
+    const passed = numberOrNull(record.passed);
+    const failed = numberOrNull(record.failed);
+    if (total === null || passed === null || failed === null)
+        return null;
+    if (total < 0 || passed < 0 || failed < 0)
+        return null;
+    if (passed + failed !== total)
+        return null;
+    const passRate = total > 0 ? passed / total : 0;
+    return { total, passed, failed, passRate };
+}
+function metricsWithExitCodeSignal(metrics, exitCode) {
+    if (exitCode === null || exitCode <= 0)
+        return metrics;
+    if (!metrics)
+        return { total: 1, passed: 0, failed: 1, passRate: 0 };
+    if (metrics.failed > 0 || metrics.passRate < 1)
+        return metrics;
+    const total = metrics.total + 1;
+    const failed = metrics.failed + 1;
+    return {
+        total,
+        passed: metrics.passed,
+        failed,
+        passRate: total > 0 ? metrics.passed / total : 0,
+    };
+}
+function changeScopeVerdict(outputText, expected, command) {
+    if (expected.length === 0)
+        return undefined;
+    const collection = parseTestCollection(outputText);
+    const observed = collection?.paths ?? [];
+    if (observed.length > 0) {
+        return pathsIntersect(observed, expected) ? 'in-scope' : 'out-of-scope';
+    }
+    const commandPaths = commandTestPaths(command);
+    if (pathsIntersect(commandPaths, expected))
+        return 'in-scope';
+    const knownScope = collection !== null && collection.collected !== null;
+    return knownScope ? 'out-of-scope' : 'unknown';
+}
+function pathsIntersect(observed, expected) {
+    if (observed.length === 0 || expected.length === 0)
+        return false;
+    for (const o of observed.map(normPath)) {
+        for (const e of expected) {
+            if (o === e || o.endsWith('/' + e) || e.endsWith('/' + o)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function commandTestPaths(command) {
+    if (!command)
+        return [];
+    const paths = new Set();
+    const afterRunner = command.replace(/\b(?:pytest|py\.test|python\s+-m\s+pytest|vitest|npm\s+test|pnpm\s+test|yarn\s+test|go\s+test)\b/i, ' ');
+    for (const raw of afterRunner.split(/\s+/)) {
+        const tok = raw.trim().replace(/^['"]|['"]$/g, '');
+        if (!tok || tok.startsWith('-'))
+            continue;
+        const looksLikePath = /[\\/]/.test(tok) || /\b(?:tests?|spec|specs|benchmark_tests)\b/i.test(tok);
+        if (!looksLikePath)
+            continue;
+        if (/\.[a-z]+$/i.test(tok) && !/\.(?:py|[tj]sx?)$/i.test(tok))
+            continue;
+        paths.add(normPath(tok));
+    }
+    return [...paths];
+}
+async function readOptionalText(filePath) {
+    if (!filePath)
+        return '';
+    try {
+        return await fs.readFile(filePath, 'utf-8');
+    }
+    catch {
+        return '';
+    }
+}
+function parsePyprojectProjectName(content) {
+    let inProject = false;
+    for (const rawLine of content.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith('#'))
+            continue;
+        const section = line.match(/^\[([^\]]+)\]\s*(?:#.*)?$/);
+        if (section) {
+            inProject = section[1].trim() === 'project';
+            continue;
+        }
+        if (!inProject)
+            continue;
+        const name = line.match(/^name\s*=\s*(['"])(.*?)\1\s*(?:#.*)?$/);
+        if (name)
+            return name[2];
+    }
+    return undefined;
+}
+function sameResolvedPath(left, right) {
+    const normalizedLeft = path.resolve(left);
+    const normalizedRight = path.resolve(right);
+    if (process.platform === 'win32') {
+        return normalizedLeft.toLowerCase() === normalizedRight.toLowerCase();
+    }
+    return normalizedLeft === normalizedRight;
+}
+function isInside(root, candidate) {
+    const relative = path.relative(path.resolve(root), path.resolve(candidate));
+    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+function formatProjectPath(projectRoot, filePath) {
+    const relative = path.relative(projectRoot, filePath);
+    if (relative && !relative.startsWith('..') && !path.isAbsolute(relative)) {
+        return relative.split(path.sep).join('/');
+    }
+    return path.normalize(filePath);
+}
+function normPath(p) {
+    return p.replace(/\\/g, '/').toLowerCase().replace(/^\.\//, '').replace(/::.*/, '');
+}
+function stringOrUndefined(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function numberOrNull(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : null;
+}
+async function fileExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function sha256(content) {
+    return createHash('sha256').update(content).digest('hex');
+}
+//# sourceMappingURL=runner-evidence.js.map

package/dist/core/self-evolution/candidates.js

@@ -376,7 +376,6 @@ export async function listCandidates(layout, filter) {
             raw = await fs.readFile(candidateJsonPath, 'utf8');
         }
         catch {
-            // eslint-disable-next-line no-console
             console.warn(`[candidates] skipping ${entry.name}: missing or unreadable ${CANDIDATE_JSON_FILE}`);
             continue;
         }
@@ -385,7 +384,6 @@ export async function listCandidates(layout, filter) {
             parsed = JSON.parse(raw);
         }
         catch {
-            // eslint-disable-next-line no-console
             console.warn(`[candidates] skipping ${entry.name}: invalid JSON in ${CANDIDATE_JSON_FILE}`);
             continue;
         }