@sanqianx/project-knowledge 5.0.24 → 5.0.26

package/_site/_test/parallel-logging-acceptance-log008-test.js

@@ -0,0 +1,180 @@
+'use strict';
+// P-LOG-ACCEPTANCE-01 LOG-008 acceptance driver (real product page in a real
+// browser against an isolated managed instance).
+//
+// Case (qa-autopilot/config/test-cases.json LOG-008, P1):
+//   steps:    查询超时和导出失败分别触发。
+//   expected: 1) UI显示失败。
+//             2) 不能生成空文件冒充成功导出。
+//
+// Real behaviour under test: api() (ui/product.js:31-43) aborts GETs after
+// 3s and loadLogs leaves the previous DOM intact on failure; on() toasts the
+// error message. The lane observation proxy delays /api/logs by 5s (> the 3s
+// timeout) for the query-timeout phase. For export failure, a file placed at
+// <dataDir>/cache/exports makes exportToFile's mkdirSync throw → the route
+// returns 500 → exportLogs throws 诊断导出失败。 → toast, and no download may
+// appear. A control export after unblocking proves the route recovers.
+
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+
+// Portable isolation (P-QA-LOG-INTEGRATION-5025): the temp root comes from
+// PK_TEST_TEMP_ROOT or os.tmpdir() and must live outside the source tree;
+// HOME/APPDATA/LOCALAPPDATA/TEMP/CODEX_HOME/CLAUDE_CONFIG_DIR and the dual
+// product data roots are redirected before any other module is loaded.
+const { installLoggingTestEnv, resolveEvidenceDir } = require('./helpers/parallel-logging-integration-5025-env');
+const lane = installLoggingTestEnv({ caseId: 'LOG-008', prefix: 'log008' });
+const laneTmp = lane.laneTmp;
+
+const { spawnServer } = require('./helpers/spawn-server');
+const { findChrome } = require('./helpers/find-chrome');
+const { launchCdpBrowser, waitFor } = require('./helpers/cdp-browser');
+const freePort = require('./helpers/free-port');
+const { createLoggingAcceptanceFixture, writeProjectLogs } = require('./helpers/parallel-logging-acceptance-fixture');
+const { createObservationProxy } = require('./helpers/parallel-logging-acceptance-proxy');
+
+const ROOT = path.resolve(__dirname, '../..');
+const ARTIFACTS = resolveEvidenceDir(path.resolve(ROOT, 'qa-autopilot/artifacts/parallel-20261023/logging-acceptance-r1/evidence/log008'));
+
+const PROJECT_A = 'project-log008-alpha';
+const run = crypto.randomBytes(6).toString('hex');
+const MARK = `LOG008-Q-${run}`;
+
+async function main() {
+  fs.mkdirSync(ARTIFACTS, { recursive: true });
+  const evidence = { caseId: 'LOG-008', startedAt: new Date().toISOString(), marker: MARK, phases: {} };
+
+  const fixture = await createLoggingAcceptanceFixture({
+    caseId: 'log008',
+    projects: [{ projectId: PROJECT_A, displayName: 'LOG008甲项目' }],
+  });
+  await writeProjectLogs(fixture.logger, PROJECT_A, [
+    { level: 'info', event: 'log008.seed.1', message: `LOG008 seed 1 ${run}`, operationId: `op-log008-seed-1-${run}` },
+    { level: 'warn', event: 'log008.seed.2', message: `LOG008 seed 2 ${run}`, operationId: `op-log008-seed-2-${run}` },
+    { level: 'info', event: `log008.hit`, message: `${MARK} 命中记录`, operationId: `op-log008-hit-${run}` },
+  ]);
+  await fixture.logger.close();
+
+  const port = await freePort();
+  const proxyPort = await freePort();
+  const base = `http://127.0.0.1:${port}`;
+  const server = spawnServer({ root: ROOT, port, dataDir: fixture.dataDir, tag: 'log008', stdio: 'ignore' });
+  let browser;
+  let proxy;
+  try {
+    await waitFor(async () => { try { return (await fetch(`${base}/api/health`)).ok; } catch { return false; } }, 'isolated web shell', 20000);
+    proxy = await createObservationProxy({ targetPort: port, port: proxyPort });
+    evidence.server = { pid: server.child.pid, port, proxyPort, dataDir: fixture.dataDir };
+
+    browser = await launchCdpBrowser({ chrome: findChrome(), profileDir: path.join(laneTmp, 'browser'), url: proxy.url, width: 1440, height: 900 });
+    const runExpr = expression => browser.evaluate(expression);
+    const click = selector => runExpr(`document.querySelector(${JSON.stringify(selector)}).click()`);
+    const readDom = () => runExpr(`JSON.stringify({ count: document.querySelectorAll('#logsContent .log-entry').length, toastHidden: document.getElementById('toast').hidden, toastText: document.getElementById('toast').textContent })`);
+    evidence.browser = await runExpr('navigator.userAgent');
+
+    await waitFor(() => runExpr(`document.getElementById('projectSelect') && document.getElementById('projectSelect').length >= 1`), 'isolated project registered', 20000);
+    await runExpr(`document.getElementById('projectSelect').value = ${JSON.stringify(PROJECT_A)}; document.getElementById('projectSelect').dispatchEvent(new Event('change'))`);
+    await waitFor(() => runExpr(`document.getElementById('projectSelect').value === ${JSON.stringify(PROJECT_A)}`), 'project A selected');
+
+    // Baseline: healthy query first (search narrows to the marker's record).
+    await click('#openSystem');
+    await runExpr(`document.getElementById('logsScope').value = 'project'; document.getElementById('logsSearch').value = ''`);
+    await click('#openLogs');
+    await waitFor(async () => {
+      const dom = JSON.parse(await readDom());
+      return dom.count >= 3;
+    }, 'diagnostics dialog rendered the project records', 20000);
+    const domBaseline = JSON.parse(await readDom());
+
+    // expected1a (query timeout): delay /api/logs past api()'s 3s timeout.
+    proxy.setDelay('/api/logs', 5000);
+    await runExpr(`document.getElementById('logsSearch').value = ${JSON.stringify(MARK)}`);
+    await click('#loadLogs');
+    await waitFor(async () => {
+      const dom = JSON.parse(await readDom());
+      return !dom.toastHidden && dom.toastText.includes('状态读取超时');
+    }, 'timeout toast appears for the slow query', 8000);
+    const domTimeout = JSON.parse(await readDom());
+    evidence.phases.queryTimeout = {
+      baselineEntries: domBaseline.count,
+      entriesAfterTimeout: domTimeout.count,
+      toastText: domTimeout.toastText,
+      previousContentPreserved: domTimeout.count === domBaseline.count,
+      delayedQueryStillNotNarrowed: domTimeout.count !== 1,
+    };
+    if (!domTimeout.toastText.includes('状态读取超时')) throw new Error('UI did not surface the query timeout');
+    if (domTimeout.count !== domBaseline.count) throw new Error('timeout wiped the previously rendered records');
+    await browser.screenshot(path.join(ARTIFACTS, 'log008-query-timeout-toast.png'));
+    proxy.setDelay('/api/logs', null);
+    // Let the delayed response land and the toast clear before the next phase.
+    await new Promise(resolve => setTimeout(resolve, 5200));
+
+    // expected1b + expected2 (export failure): block cache/exports with a file.
+    const downloadDir = path.join(ARTIFACTS, 'downloads');
+    fs.mkdirSync(downloadDir, { recursive: true });
+    await browser.send('Page.setDownloadBehavior', { behavior: 'allow', downloadPath: downloadDir });
+    const exportsPath = path.join(fixture.dataDir, 'cache', 'exports');
+    const exportsWasDirectory = fs.existsSync(exportsPath) && fs.statSync(exportsPath).isDirectory();
+    if (exportsWasDirectory) fs.rmSync(exportsPath, { recursive: true, force: true });
+    fs.mkdirSync(path.dirname(exportsPath), { recursive: true });
+    fs.writeFileSync(exportsPath, 'blocked by LOG-008 driver');
+    const downloadsBefore = fs.readdirSync(downloadDir).length;
+
+    await runExpr(`document.getElementById('logsSearch').value = ''`);
+    await click('#exportLogs');
+    await waitFor(async () => {
+      const dom = JSON.parse(await readDom());
+      return !dom.toastHidden && dom.toastText.includes('诊断导出失败');
+    }, 'export failure toast appears', 8000);
+    await new Promise(resolve => setTimeout(resolve, 1500));
+    const downloadsAfter = fs.readdirSync(downloadDir).length;
+    const domExportFail = JSON.parse(await readDom());
+    const exportProxyEntry = proxy.state.requests.filter(r => r.pathname === '/api/logs/export').slice(-1)[0] || null;
+    evidence.phases.exportFailure = {
+      toastText: domExportFail.toastText,
+      exportStatusViaProxy: exportProxyEntry && exportProxyEntry.status,
+      downloadsBefore, downloadsAfter,
+      downloadedFileCount: downloadsAfter - downloadsBefore,
+      noFakeEmptyFile: downloadsAfter === downloadsBefore,
+    };
+    if (!domExportFail.toastText.includes('诊断导出失败')) throw new Error('UI did not surface the export failure');
+    if (downloadsAfter !== downloadsBefore) throw new Error('a download file appeared despite the failed export');
+    await browser.screenshot(path.join(ARTIFACTS, 'log008-export-failure-toast.png'));
+
+    // Control: unblock and confirm the export route recovers (no lasting damage).
+    fs.rmSync(exportsPath, { force: true });
+    const controlRes = await fetch(`${base}/api/logs/export?projectId=${PROJECT_A}`);
+    const controlText = await controlRes.text();
+    evidence.phases.exportRecovery = {
+      status: controlRes.status,
+      exportedLines: controlText.trim().split('\n').filter(Boolean).length,
+    };
+    if (controlRes.status !== 200 || !controlText.includes('log008.seed.1')) throw new Error('export route did not recover after unblocking');
+
+    if (browser.exceptions.length) throw new Error(`browser exceptions: ${JSON.stringify(browser.exceptions)}`);
+    evidence.verdict = { 'expected1 UI显示失败(超时+导出)': 'PASS', 'expected2 未生成空文件冒充导出成功': 'PASS' };
+    console.log('LOG-008 PASS');
+    process.exitCode = 0;
+  } catch (error) {
+    evidence.verdict = { failed: String((error && error.stack) || error) };
+    try {
+      if (browser) {
+        evidence.debugDom = JSON.parse(await browser.evaluate(`JSON.stringify({ dialogOpen: document.getElementById('logsDialog').open, entries: document.querySelectorAll('#logsContent .log-entry').length, toast: document.getElementById('toast').textContent })`));
+        evidence.debugConsoleErrors = browser.consoleErrors;
+      }
+      if (proxy) evidence.debugProxy = proxy.state.snapshot();
+    } catch {}
+    process.exitCode = 1;
+    console.error(`LOG-008 FAIL: ${error.message}`);
+  } finally {
+    evidence.finishedAt = new Date().toISOString();
+    try { if (browser) await browser.screenshot(path.join(ARTIFACTS, 'log008-final.png')); } catch {}
+    fs.mkdirSync(ARTIFACTS, { recursive: true });
+    fs.writeFileSync(path.join(ARTIFACTS, 'log008-evidence.json'), JSON.stringify(evidence, null, 2) + '\n');
+    try { await browser?.close(); } finally { try { if (proxy) await proxy.close(); } finally { try { await server.cleanup(); } finally { fixture.cleanup(); } } }
+    lane.cleanup();
+  }
+}
+
+main();

package/_site/_test/parallel-logging-fix-r2-crash-probe.js

@@ -0,0 +1,271 @@
+'use strict';
+// P-LOG-SAFETY-R2 hook floating-rejection probe (lane-exclusive prefix
+// parallel-logging-fix-r2-*).
+//
+// Scenario: a route-acceptable but semantically incomplete hook event
+// (schema ok, projectId registered, repoRoot non-empty, head NOT a full
+// SHA) is POSTed to an isolated legacy instance with real registered Git
+// fixtures. The route answers 202 and the background task fails for a
+// legitimate reason (scanner.validateSha). This probe observes what the
+// server PROCESS does next:
+//
+//   --expect red    old candidate: unhandledRejection terminates the whole
+//                   server (R1 finding findings/log004-hook-unhandled-rejection).
+//   --expect green  fixed candidate: same PID stays healthy, failure
+//                   diagnostics remain traceable (background.operation_failed
+//                   with the operationId), the OTHER project keeps serving,
+//                   and no fake succeeded record appears.
+//   --scenario engine-ack
+//                   observation-only: engine-ownership instance (dead bridge
+//                   URL) ack behaviour for the same payload; recorded pre-fix
+//                   and post-fix to prove the engine branch is untouched.
+//
+// Isolation: independent KB_DATA_DIR/KB_KNOWLEDGE_DATA_DIR (fixture +
+// spawnServer), ephemeral port, TEMP/TMP/TMPDIR under the lane temp root.
+// No payload is ever sent to the real desktop instance on 5757/5760.
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+// Portable isolation (P-QA-LOG-INTEGRATION-5025): the temp root comes from
+// PK_TEST_TEMP_ROOT or os.tmpdir() and must live outside the source tree;
+// HOME/APPDATA/LOCALAPPDATA/TEMP/CODEX_HOME/CLAUDE_CONFIG_DIR and the dual
+// product data roots are redirected before any other module is loaded.
+const { installLoggingTestEnv, resolveEvidenceDir } = require('./helpers/parallel-logging-integration-5025-env');
+const lane = installLoggingTestEnv({ caseId: 'LOGFIXR2-CRASH', prefix: 'logfixr2-crash' });
+const laneTmp = lane.laneTmp;
+
+const { spawnServer } = require('./helpers/spawn-server');
+const freePort = require('./helpers/free-port');
+const { createLoggingAcceptanceFixture } = require('./helpers/parallel-logging-acceptance-fixture');
+
+const ROOT = path.resolve(__dirname, '../..');
+const ARTIFACTS = resolveEvidenceDir(path.resolve(ROOT, 'qa-autopilot/artifacts/parallel-20261023/logging-fix-r2/evidence/crash'));
+
+const PROJECT_A = 'project-logfixr2-alpha';
+const PROJECT_B = 'project-logfixr2-beta';
+const INVALID_OPERATION = 'op-logfixr2-invalid-0001';
+const SCENARIO = process.argv.includes('--scenario')
+  ? process.argv[process.argv.indexOf('--scenario') + 1]
+  : 'legacy-invalid';
+const EXPECT = process.argv.includes('--expect')
+  ? process.argv[process.argv.indexOf('--expect') + 1]
+  : null;
+const HARD_TIMEOUT_MS = 120000;
+
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+const now = () => new Date().toISOString();
+
+function projectLogRecords(dataDir, projectId) {
+  const dir = path.join(dataDir, 'logs', 'projects', projectId);
+  if (!fs.existsSync(dir)) return [];
+  const records = [];
+  for (const file of fs.readdirSync(dir).filter(name => name.endsWith('.jsonl')).sort()) {
+    for (const line of fs.readFileSync(path.join(dir, file), 'utf8').split('\n')) {
+      if (!line.trim()) continue;
+      try { records.push(JSON.parse(line)); } catch {}
+    }
+  }
+  return records;
+}
+
+async function fetchJson(url, options) {
+  const res = await fetch(url, options);
+  let body = null;
+  try { body = await res.json(); } catch {}
+  return { status: res.status, ok: res.ok, body };
+}
+
+async function main() {
+  fs.mkdirSync(ARTIFACTS, { recursive: true });
+  const evidence = {
+    probe: 'parallel-logging-fix-r2-crash-probe.js',
+    scenario: SCENARIO,
+    expect: EXPECT,
+    startedAt: now(),
+    serverAppSha256: (() => {
+      const crypto = require('node:crypto');
+      return crypto.createHash('sha256').update(fs.readFileSync(path.join(ROOT, '_site', 'lib', 'server-app.js'))).digest('hex');
+    })(),
+  };
+
+  const fixture = await createLoggingAcceptanceFixture({
+    caseId: 'logfixr2',
+    projects: [
+      { projectId: PROJECT_A, displayName: 'LOGFIXR2甲项目' },
+      { projectId: PROJECT_B, displayName: 'LOGFIXR2乙项目' },
+    ],
+  });
+  await fixture.logger.close();
+
+  const port = await freePort();
+  const base = `http://127.0.0.1:${port}`;
+  const analysisOwner = SCENARIO === 'engine-ack' ? 'engine' : 'legacy';
+  const server = spawnServer({
+    root: ROOT,
+    port,
+    dataDir: fixture.dataDir,
+    tag: 'logfixr2',
+    analysisOwner,
+    extraEnv: { KB_AUTOMATION_FAKE_CLAUDE: '1' },
+  });
+  let stdout = '';
+  let stderr = '';
+  server.child.stdout.on('data', chunk => { stdout += chunk; });
+  server.child.stderr.on('data', chunk => { stderr += chunk; });
+  let exitInfo = null;
+  server.child.once('exit', (code, signal) => { exitInfo = { code, signal, at: now() }; });
+  evidence.server = { pid: server.child.pid, port, analysisOwner, dataDir: fixture.dataDir };
+
+  try {
+    // Boot wait (real health endpoint, not a sleep guess).
+    const bootDeadline = Date.now() + 30000;
+    let health = null;
+    while (Date.now() < bootDeadline) {
+      try {
+        const res = await fetch(`${base}/api/health`);
+        if (res.ok) { health = await res.json(); break; }
+      } catch {}
+      await sleep(200);
+    }
+    if (!health) throw new Error('isolated server did not become healthy within 30s');
+    evidence.boot = { healthyAt: now(), pid: server.child.pid };
+
+    // Route-acceptable but semantically incomplete hook payload (head is not
+    // a full 40-char SHA). The route layer accepts it; the background task
+    // fails in scanner.validateSha for a legitimate reason.
+    const repoA = fixture.projects.find(p => p.projectId === PROJECT_A).repo.path;
+    const hookPayload = {
+      schema: 'hook-event/v2',
+      projectId: PROJECT_A,
+      repoRoot: repoA,
+      head: 'deadbeef-not-a-full-sha',
+      branch: 'main',
+      operationId: INVALID_OPERATION,
+    };
+    const post = await fetchJson(`${base}/api/hooks/post-commit`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify(hookPayload),
+    });
+    evidence.hookPost = { at: now(), status: post.status, body: post.body };
+
+    if (SCENARIO === 'engine-ack') {
+      // Observation only: the engine branch is untouched by the fix; capture
+      // its synchronous ack for pre/post parity.
+      await sleep(1000);
+      const healthAfter = await fetchJson(`${base}/api/health`);
+      evidence.engineAck = { healthAfter: { status: healthAfter.status, ok: healthAfter.ok }, exited: exitInfo ? exitInfo : null };
+      evidence.observation = 'engine-branch ack recorded';
+      fs.writeFileSync(path.join(ARTIFACTS, 'engine-ack-result.json'), JSON.stringify(evidence, null, 2) + '\n');
+      console.log(`engine-ack: hook status=${post.status} health=${healthAfter.status} exit=${exitInfo ? exitInfo.code : 'alive'}`);
+      process.exitCode = 0;
+      return;
+    }
+
+    // Observe the process for up to 15s after the accepted failure.
+    const watchDeadline = Date.now() + 15000;
+    const healthTrace = [];
+    let diedAt = null;
+    while (Date.now() < watchDeadline) {
+      let alive = false;
+      try { const res = await fetch(`${base}/api/health`, { signal: AbortSignal.timeout(1500) }); alive = res.ok; } catch {}
+      healthTrace.push({ at: now(), alive });
+      if (!alive) { diedAt = now(); break; }
+      if (exitInfo) break;
+      await sleep(250);
+    }
+    // Give a possibly-terminating process a moment to fully exit so exitInfo
+    // is captured deterministically.
+    await sleep(1500);
+    evidence.healthTrace = healthTrace;
+    evidence.diedAt = diedAt;
+    evidence.exitInfo = exitInfo;
+
+    const records = projectLogRecords(fixture.dataDir, PROJECT_A);
+    const failed = records.filter(r => r.event === 'background.operation_failed');
+    const completed = records.filter(r => r.event === 'background.operation_completed');
+    evidence.diagnostics = {
+      operationFailedRecords: failed.map(r => ({
+        operationId: r.operationId,
+        errorCode: r.error && r.error.code,
+        errorMessage: r.error && r.error.message,
+        stackHead: (r.error && r.error.stack || []).slice(0, 4),
+        ts: r.ts,
+      })),
+      invalidOperationCompleted: completed.filter(r => r.operationId === INVALID_OPERATION).map(r => r.operationId),
+    };
+
+    let controlProjectOk = null;
+    let controlEvidence = null;
+    if (exitInfo === null) {
+      // Server survived: prove the OTHER project still serves real requests.
+      const goalRes = await fetchJson(`${base}/api/projects/${PROJECT_B}/goal`, {
+        method: 'PUT',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ content: `LOGFIXR2 control goal ${Date.now()} pad-${'x'.repeat(64)}` }),
+      });
+      const logsRes = await fetchJson(`${base}/api/logs?pageSize=50&projectId=${PROJECT_B}`);
+      const goalUpdated = ((logsRes.body || {}).entries || []).some(e => e.event === 'goal.updated');
+      controlEvidence = { goalPutStatus: goalRes.status, logsStatus: logsRes.status, goalUpdatedSeen: goalUpdated };
+      controlProjectOk = goalRes.ok && logsRes.ok && goalUpdated;
+      evidence.controlProject = controlEvidence;
+    }
+
+    // Verdict against the declared expectation.
+    const serverDied = exitInfo !== null || diedAt !== null;
+    const failedForInvalid = evidence.diagnostics.operationFailedRecords.some(r => r.operationId === INVALID_OPERATION);
+    const noFakeSuccess = evidence.diagnostics.invalidOperationCompleted.length === 0;
+    let verdict;
+    if (EXPECT === 'red') {
+      verdict = { serverDied, failedDiagnosticPresent: failedForInvalid || serverDied };
+      evidence.verdict = verdict;
+      if (!serverDied) throw new Error('RED expected: server was expected to die from unhandledRejection but stayed healthy');
+    } else if (EXPECT === 'green') {
+      verdict = {
+        samePidAlive: exitInfo === null && diedAt === null,
+        failureDiagnosticTraceable: failedForInvalid,
+        noFakeSucceeded: noFakeSuccess,
+        controlProjectOk,
+      };
+      evidence.verdict = verdict;
+      if (!(verdict.samePidAlive && verdict.failureDiagnosticTraceable && verdict.noFakeSucceeded && verdict.controlProjectOk)) {
+        throw new Error(`GREEN expectation not met: ${JSON.stringify(verdict)}`);
+      }
+    } else {
+      evidence.verdict = { observedOnly: true, serverDied };
+    }
+
+    const file = EXPECT === 'red' ? 'red-result.json' : EXPECT === 'green' ? 'green-result.json' : 'observation.json';
+    fs.writeFileSync(path.join(ARTIFACTS, file), JSON.stringify(evidence, null, 2) + '\n');
+    console.log(`${EXPECT || 'observe'}: serverDied=${serverDied} exit=${exitInfo ? exitInfo.code : 'alive'} failedDiagnostic=${failedForInvalid} fakeSuccess=${!noFakeSuccess} controlOk=${controlProjectOk}`);
+    process.exitCode = 0;
+  } catch (error) {
+    evidence.error = String((error && error.stack) || error);
+    fs.writeFileSync(path.join(ARTIFACTS, `${EXPECT || 'observe'}-failure.json`), JSON.stringify(evidence, null, 2) + '\n');
+    console.error(`crash-probe FAIL: ${error.message}`);
+    process.exitCode = 1;
+  } finally {
+    evidence.finishedAt = now();
+    evidence.serverStdout = stdout.slice(-4000);
+    evidence.serverStderr = stderr.slice(-4000);
+    try {
+      fs.writeFileSync(path.join(ARTIFACTS, `${EXPECT || 'observe'}-server-io.json`), JSON.stringify({ stdout: stdout.slice(-8000), stderr: stderr.slice(-8000), exitInfo }, null, 2) + '\n');
+    } catch {}
+    try { await server.cleanup(); } finally { fixture.cleanup(); }
+    lane.cleanup();
+  }
+}
+
+const hardTimer = setTimeout(() => {
+  // Total-timeout scene preservation: dump what we know and stop.
+  try {
+    fs.mkdirSync(ARTIFACTS, { recursive: true });
+    fs.writeFileSync(path.join(ARTIFACTS, 'hard-timeout.json'), JSON.stringify({ at: now(), scenario: SCENARIO, expect: EXPECT }, null, 2) + '\n');
+  } catch {}
+  console.error('crash-probe HARD TIMEOUT');
+  process.exit(2);
+}, HARD_TIMEOUT_MS);
+hardTimer.unref();
+
+main();