atris 3.58.6 → 3.58.8

package/lib/receipt-block.js

@@ -98,18 +98,116 @@ function directProofText(value) {
   return ran ? `${ran[1]} passed` : text;
 }
 
-function proofText(receipt) {
+// A receipt is a text from a good employee: one sentence a friend would send,
+// plus one link a stranger can check. Ids, statuses, scores and verifier
+// output stay underneath (they feed the rating); they never lead the surface.
+// Standard: atris-labs atris/wiki/systems/receipt-standard.md
+
+function sentence(value) {
+  const text = trimPunctuation(value);
+  if (!text) return '';
+  return `${text.charAt(0).toUpperCase()}${text.slice(1)}.`;
+}
+
+// Bracketed IPv6 hosts need their own alternative: the plain class stops at
+// ] and would cut http://[::1]:3000 down to http://[::1 .
+const URL_RE = /https?:\/\/\[[0-9a-f.:]+\][^\s)>\]]*|https?:\/\/[^\s)>\]]+/i;
+const URL_RE_GLOBAL = new RegExp(URL_RE.source, 'gi');
+
+// A stranger cannot open localhost, loopback or *.local addresses, so they
+// never count as the check link no matter which field they came from.
+// Parsing with URL normalizes tricks like 127.1 or 0x7f.1 into 127.0.0.1.
+function localCheckUrl(url) {
+  let host;
+  try {
+    host = new URL(url).hostname.toLowerCase();
+  } catch {
+    return false;
+  }
+  if (host.startsWith('[') && host.endsWith(']')) host = host.slice(1, -1);
+  return host === 'localhost'
+    || host === '0.0.0.0'
+    || host === '::1'
+    || host.startsWith('127.')
+    || host.endsWith('.local');
+}
+
+// A checked/tested note that is nothing but a local URL carries no check a
+// stranger can run; the verifier line speaks instead.
+function localOnlyUrl(text) {
+  const value = trimPunctuation(text);
+  return /^https?:\/\/\S+$/i.test(value) && localCheckUrl(value);
+}
+
+function firstUrl(...values) {
+  for (const value of values) {
+    if (!value) continue;
+    for (const raw of String(value).match(URL_RE_GLOBAL) || []) {
+      const url = raw.replace(/[.,;:]+$/, '');
+      if (!localCheckUrl(url)) return url;
+    }
+  }
+  return '';
+}
+
+// The link a stranger can click. Read explicit link fields first, then any
+// URL the landing text already mentions. Local-only hosts never count, and
+// empty means the receipt has none.
+function checkLink(receipt) {
+  const land = landing(receipt);
+  const res = result(receipt);
+  return firstUrl(
+    land.link, land.url, land.check_url, land.proof_url,
+    res.link, res.url, res.pr_url, res.share_url, res.tick?.pr_url, res.tick?.share_url,
+    land.checked, land.tested,
+  );
+}
+
+// What a reader can check: the link when there is one, else the plain
+// check that passed. Never "verifier passed" or "receipt is present".
+function checkText(receipt) {
+  const link = checkLink(receipt);
+  if (link) return link;
   const land = landing(receipt);
   const verifier = verifierResult(receipt);
-  if (land.checked) return directProofText(land.checked);
-  if (land.tested) return directProofText(land.tested);
+  if (land.checked && !localOnlyUrl(land.checked)) return directProofText(land.checked);
+  if (land.tested && !localOnlyUrl(land.tested)) return directProofText(land.tested);
   if (verifier) {
-    const command = lowerLine(verifier.command || receipt?.verifier || 'configured verifier');
+    const command = lowerLine(verifier.command || receipt?.verifier || 'the checks');
     return `${command} ${verifier.passed ? 'passed' : 'failed'}`;
   }
-  if (result(receipt).passed === true) return 'receipt says verifier passed';
-  if (receipt?.at) return `receipt saved at ${lowerLine(receipt.at)}`;
-  return 'receipt is present';
+  if (result(receipt).passed === true) return 'the checks passed';
+  return '';
+}
+
+// Dollars a mission actually brought in. Read from the landing (or result)
+// so a member can write it next to what happened; the backend sums the same
+// field into the member rating. Only a real number or a plain decimal string
+// may count: Number() alone would read true as 1, [5] as 5, "0x10" as 16 and
+// "1e3" as 1000. Junk and negatives count as zero.
+const PLAIN_DECIMAL_RE = /^\d+(\.\d+)?$/;
+
+function plainDecimalAmount(value) {
+  if (typeof value === 'number') return Number.isFinite(value) ? value : 0;
+  if (typeof value !== 'string') return 0;
+  const text = value.trim();
+  return PLAIN_DECIMAL_RE.test(text) ? Number(text) : 0;
+}
+
+function earnedUsd(receipt) {
+  const land = landing(receipt);
+  const res = result(receipt);
+  for (const value of [land.earned_usd, res.earned_usd, res.tick?.earned_usd]) {
+    if (value === undefined || value === null || value === '') continue;
+    const amount = plainDecimalAmount(value);
+    return amount > 0 ? Math.round(amount * 100) / 100 : 0;
+  }
+  return 0;
+}
+
+function usdText(amount) {
+  const whole = Number.isInteger(amount);
+  return `$${amount.toLocaleString('en-US', { minimumFractionDigits: whole ? 0 : 2, maximumFractionDigits: 2 })}`;
 }
 
 function nextText(receipt) {
@@ -117,43 +215,53 @@ function nextText(receipt) {
   return lowerLine(text);
 }
 
+function whatText(receipt, max = 180) {
+  return historicalLandingText(trimPunctuation(changedText(receipt)), max);
+}
+
+// One line: "What happened. Check it: <link or check>."
+function checkLine(receipt, max = 160) {
+  const check = trimPunctuation(checkText(receipt));
+  if (!check) return '';
+  // A link stays bare so it copies clean; a plain check reads as a sentence.
+  return firstUrl(check) ? `Check it: ${check}` : `Check it: ${truncateLine(check, max)}.`;
+}
+
 function renderEmailLine(receipt) {
-  const what = historicalLandingText(trimPunctuation(changedText(receipt)), 180);
-  const scale = scaleText(receipt);
-  const proof = historicalLandingText(trimPunctuation(proofText(receipt)), 90);
-  return `${what}; ${scale}; we know because ${proof}.`;
+  const what = sentence(whatText(receipt));
+  const check = checkLine(receipt);
+  return check ? `${what} ${check}` : what;
 }
 
 function renderMorningCardRow(receipt) {
-  return `- mission: ${renderEmailLine(receipt).replace(/\.$/, '')}`;
+  return `- ${renderEmailLine(receipt).replace(/\.$/, '')}`;
 }
 
+// Three lines lead. The machinery (size, status, mission id) sits below as
+// details, where a builder can find it and a customer never has to read it.
 function renderPageSection(receipt) {
   const next = nextText(receipt);
-  const lines = [
-    '## mission receipt',
-    '',
-    `- what: ${truncateLine(trimPunctuation(changedText(receipt)), 160)}`,
-    `- how big: ${scaleText(receipt)}`,
-    `- how we know: ${truncateLine(trimPunctuation(proofText(receipt)), 160)}`,
-    `- status: ${statusText(receipt)}`,
-  ];
-  if (receipt?.mission_id) lines.push(`- mission: ${lowerLine(receipt.mission_id)}`);
-  if (next) lines.push(`- next: ${truncateLine(trimPunctuation(next), 160)}`);
+  const check = checkLine(receipt);
+  const lines = ['## mission receipt', '', sentence(whatText(receipt, 160))];
+  if (check) lines.push(check);
+  if (next) lines.push(`Next: ${sentence(truncateLine(next, 160))}`);
+  const details = [scaleText(receipt), `status ${statusText(receipt)}`];
+  const earned = earnedUsd(receipt);
+  if (earned > 0) details.push(`earned ${usdText(earned)}`);
+  if (receipt?.mission_id) details.push(`mission ${lowerLine(receipt.mission_id)}`);
+  lines.push('', `details: ${details.join('; ')}`);
   return lines.join('\n');
 }
 
 function renderCard(receipt) {
-  const status = statusText(receipt);
-  const what = truncateLine(trimPunctuation(changedText(receipt)), 64);
-  const scale = scaleText(receipt);
-  const proof = truncateLine(trimPunctuation(proofText(receipt)), 88);
+  const what = sentence(whatText(receipt, 64));
+  const check = trimPunctuation(checkText(receipt));
   return {
     kind: 'statement',
     headline: what,
     text: what,
-    kicker: `${status} mission receipt`,
-    sub: `${scale}; ${proof}`,
+    kicker: 'mission receipt',
+    sub: check ? `Check it: ${truncateLine(check, 88)}` : '',
     brand: 'atris',
     size: 'og',
     theme: 'atris',
@@ -161,6 +269,7 @@ function renderCard(receipt) {
 }
 
 module.exports = {
+  earnedUsd,
   renderCard,
   renderPageSection,
   renderEmailLine,

package/lib/rsi-record.js

@@ -0,0 +1,335 @@
+'use strict';
+
+// Record one bounded improvement attempt into the Dream-RSI ledger.
+//
+// When the workspace root contains backend/scripts/rsi/record.py (the
+// backend checkout with the recorder), a command that runs one bounded
+// attempt at improving the workspace (improve tick, pulse tick, drive)
+// wraps the work in start-tree -> choose -> open -> finish. Every step is
+// best-effort: a missing recorder, a failed choose, or a dead python logs
+// one line and the command's behavior and exit code stay untouched.
+//
+// State lands in $ATRIS_RSI_STATE (default <root>/.atris/state/rsi), the
+// same paths backend/scripts/rsi/schema.py uses.
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+// Lane name for bounded self-improvement attempts recorded from this CLI.
+const IMPROVE_LANE = 'improve_tick';
+// While an attempt node is open, nested atris subprocesses (local mission
+// fallback, autopilot, mission ticks spawned by drive) must not open their
+// own nodes: one command run is one attempt.
+const GUARD_ENV = 'ATRIS_RSI_ATTEMPT_NODE';
+const SPAWN_TIMEOUT_MS = 20000;
+const NODE_SCHEMA = 'atris.rsi.node.v1';
+
+function scriptsDir(root) {
+  return path.join(root, 'backend', 'scripts', 'rsi');
+}
+
+function recorderPath(root) {
+  const p = path.join(scriptsDir(root), 'record.py');
+  return fs.existsSync(p) ? p : null;
+}
+
+// The repo's own venv first (same as scripts/rsi_record_wrap.sh), else
+// whatever python3 is on PATH.
+function pythonBin(root) {
+  const venv = path.join(root, 'venv', 'bin', 'python');
+  try {
+    fs.accessSync(venv, fs.constants.X_OK);
+    return venv;
+  } catch {
+    return 'python3';
+  }
+}
+
+function stateDir(root) {
+  return process.env.ATRIS_RSI_STATE || path.join(root, '.atris', 'state', 'rsi');
+}
+
+function attemptsPath(root) {
+  return path.join(stateDir(root), 'attempts.jsonl');
+}
+
+function dreamsPath(root) {
+  return path.join(stateDir(root), 'dreams.jsonl');
+}
+
+function currentPolicyId(root, fallback = 'p-0001') {
+  try {
+    const raw = fs.readFileSync(path.join(root, 'atris', 'rsi', 'policy.current'), 'utf8').trim();
+    return raw || fallback;
+  } catch {
+    return fallback;
+  }
+}
+
+function localDate(d = new Date()) {
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, '0');
+  const day = String(d.getDate()).padStart(2, '0');
+  return `${y}-${m}-${day}`;
+}
+
+// "<prefix>-YYYY-MM-DD[-N]" -> "YYYY-MM-DD" (record.py start-tree shape).
+function treeDate(treeId) {
+  const parts = String(treeId || '').split('-');
+  if (parts.length < 4) return null;
+  const date = parts.slice(1, 4).join('-');
+  return /^\d{4}-\d{2}-\d{2}$/.test(date) ? date : null;
+}
+
+// Read attempts.jsonl tolerantly: blank lines, non-JSON, and foreign rows
+// are skipped. Latest row per node id wins (finish appends a new row).
+function readAttemptRows(root) {
+  let lines;
+  try {
+    lines = fs.readFileSync(attemptsPath(root), 'utf8').split(/\r?\n/);
+  } catch {
+    return [];
+  }
+  const rows = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const row = JSON.parse(trimmed);
+      if (row && row.schema === NODE_SCHEMA) rows.push(row);
+    } catch {
+      // skip non-JSON rows
+    }
+  }
+  return rows;
+}
+
+function latestNodes(root) {
+  const latest = new Map();
+  for (const row of readAttemptRows(root)) {
+    if (row && row.id) latest.set(String(row.id), row);
+  }
+  return [...latest.values()];
+}
+
+// Reuse today's tree for the lane when one exists (the newest one wins when
+// a day has several), so every tick on a day shares one tree.
+function todayTreeId(root, lane, today = localDate()) {
+  const matches = new Set();
+  for (const row of readAttemptRows(root)) {
+    if (row && row.lane === lane && treeDate(row.tree_id) === today) matches.add(String(row.tree_id));
+  }
+  const sorted = [...matches].sort();
+  return sorted.length ? sorted[sorted.length - 1] : null;
+}
+
+function runPy(root, script, args, timeoutMs = SPAWN_TIMEOUT_MS) {
+  const scriptPath = path.join(scriptsDir(root), script);
+  const r = spawnSync(pythonBin(root), [scriptPath, ...args], {
+    cwd: root,
+    encoding: 'utf8',
+    timeout: timeoutMs,
+    env: process.env,
+  });
+  return {
+    ok: r.status === 0,
+    stdout: String(r.stdout || '').trim(),
+    stderr: String(r.stderr || '').trim(),
+    error: r.error || null,
+  };
+}
+
+function startTree(root, lane) {
+  const today = localDate();
+  const existing = todayTreeId(root, lane, today);
+  if (existing) return existing;
+  const r = runPy(root, 'record.py', ['start-tree', '--lane', lane, '--date', today]);
+  const id = r.ok ? (r.stdout.split('\n').pop() || '').trim() : '';
+  return id || null;
+}
+
+// Ask the live policy for one action (--w 1). Returns the first action or
+// null; an empty list means the policy chose to stop, a failure returns null.
+function chooseAction(root, treeId, { queueItems = 0, w = 1 } = {}) {
+  const choose = path.join(scriptsDir(root), 'choose.py');
+  if (!fs.existsSync(choose)) return null;
+  const r = runPy(root, 'choose.py', [
+    '--tree', treeId,
+    '--date', localDate(),
+    '--queue-items', String(queueItems),
+    '--w', String(w),
+  ]);
+  if (!r.ok) return null;
+  try {
+    const actions = JSON.parse(r.stdout);
+    return Array.isArray(actions) && actions.length ? actions[0] : null;
+  } catch {
+    return null;
+  }
+}
+
+function gitHead(root, short = false) {
+  try {
+    const args = short ? ['rev-parse', '--short', 'HEAD'] : ['rev-parse', 'HEAD'];
+    const r = spawnSync('git', ['-C', root, ...args], { encoding: 'utf8', timeout: 15000 });
+    return r.status === 0 ? String(r.stdout || '').trim() : null;
+  } catch {
+    return null;
+  }
+}
+
+function gitDirtyFiles(root) {
+  try {
+    const r = spawnSync('git', ['-C', root, 'status', '--porcelain'], { encoding: 'utf8', timeout: 15000 });
+    if (r.status !== 0) return [];
+    return String(r.stdout || '')
+      .split('\n')
+      .map((l) => l.slice(3).trim())
+      .filter(Boolean)
+      .map((f) => {
+        const arrow = f.indexOf(' -> ');
+        return arrow >= 0 ? f.slice(arrow + 4) : f;
+      });
+  } catch {
+    return [];
+  }
+}
+
+// A cheap working-tree snapshot: HEAD + the set of dirty paths. Comparing
+// two snapshots gives a tick's ACTUAL contribution; pre-existing dirt is
+// excluded so a tick is not credited for mess it did not make.
+function gitSnapshot(root) {
+  return { head: gitHead(root), dirty: new Set(gitDirtyFiles(root)) };
+}
+
+// Commits and files between a captured snapshot (or bare HEAD string) and
+// now: the committed diff plus paths the tick newly dirtied.
+function gitDelta(root, before) {
+  const out = { commits: 0, files: [] };
+  if (!root) return out;
+  const beforeHead = typeof before === 'string' ? before : (before && before.head);
+  const beforeDirty = before && before.dirty instanceof Set ? before.dirty : new Set();
+  const files = new Set();
+  try {
+    const after = gitHead(root);
+    if (beforeHead && after && beforeHead !== after) {
+      const count = spawnSync('git', ['-C', root, 'rev-list', '--count', `${beforeHead}..${after}`], { encoding: 'utf8', timeout: 15000 });
+      if (count.status === 0) out.commits = Number(String(count.stdout).trim()) || 0;
+      const diff = spawnSync('git', ['-C', root, 'diff', '--name-only', beforeHead, after], { encoding: 'utf8', timeout: 15000 });
+      if (diff.status === 0) String(diff.stdout).split('\n').map((f) => f.trim()).filter(Boolean).forEach((f) => files.add(f));
+    }
+    for (const f of gitDirtyFiles(root)) {
+      if (!beforeDirty.has(f)) files.add(f);
+    }
+  } catch {
+    // git missing or not a repo: commits 0, no files
+  }
+  out.files = [...files].slice(0, 200);
+  return out;
+}
+
+// Map a model name to a recorded engine. The schema's ENGINES are
+// codex/devin/cursor/agy/claude; unknown models return null so callers fall
+// back to 'claude' (the CLI's own runner default).
+function engineFromModel(model) {
+  const m = String(model || '').toLowerCase();
+  if (!m) return null;
+  if (m.includes('codex')) return 'codex';
+  if (m.includes('devin')) return 'devin';
+  if (m.includes('cursor') || m.includes('composer')) return 'cursor';
+  if (m.includes('agy') || m.includes('antigravity')) return 'agy';
+  if (m.includes('claude') || m.includes('sonnet') || m.includes('opus') || m.includes('haiku')) return 'claude';
+  return null;
+}
+
+/**
+ * Open one recorded attempt. Returns null when the workspace has no
+ * recorder, when a parent attempt is already open (nested call), or when
+ * any recorder step fails. Never throws.
+ *
+ * opts.engine: the engine the tick will actually use (default 'claude').
+ * opts.ground: the ground the tick targets; '' is allowed when the tick has
+ *   no notion of target.
+ * The returned attempt carries .hint = the policy-chosen action (or null),
+ * so a tick with a notion of target can steer by hint.ground.
+ */
+function beginAttempt(root, { lane = IMPROVE_LANE, engine = 'claude', ground = '', queueItems = 0, log = () => {} } = {}) {
+  try {
+    if (!root || process.env[GUARD_ENV]) return null;
+    if (!recorderPath(root)) return null;
+    const tree = startTree(root, lane);
+    if (!tree) {
+      log('rsi: recorder present but start-tree failed; attempt not recorded');
+      return null;
+    }
+    const chosen = chooseAction(root, tree, { queueItems, w: 1 });
+    const action = {
+      policy_id: (chosen && chosen.policy_id) || currentPolicyId(root),
+      kind: 'open',
+      // The ground the tick actually targeted. Callers without a notion of
+      // target pass '' (allowed); the policy's pick is exposed as .hint
+      // instead of being claimed as the ground the tick took.
+      ground: String(ground || ''),
+      engine: engine || 'claude',
+      model: chosen && chosen.model != null ? chosen.model : null,
+      cap_s: Number(chosen && chosen.cap_s) || 1800,
+      prompt_variant: (chosen && chosen.prompt_variant) || 'v1',
+    };
+    const context = {
+      base_commit: gitHead(root, true) || '',
+      ground: action.ground,
+      queue_items: queueItems,
+    };
+    const r = runPy(root, 'record.py', [
+      'open', '--tree', tree, '--lane', lane,
+      '--action-json', JSON.stringify(action),
+      '--context-json', JSON.stringify(context),
+    ]);
+    const node = r.ok ? (r.stdout.split('\n').pop() || '').trim() : '';
+    if (!node) {
+      log('rsi: node open failed; attempt not recorded');
+      return null;
+    }
+    process.env[GUARD_ENV] = node;
+    return { tree, node, lane, action, hint: chosen || null };
+  } catch (e) {
+    log(`rsi: attempt record skipped (${e && e.message ? e.message : e})`);
+    return null;
+  }
+}
+
+// Close an attempt opened by beginAttempt. Never throws; returns true when
+// the finish row was written.
+function finishAttempt(root, attempt, outcome = {}, { log = () => {} } = {}) {
+  if (!attempt || !attempt.node) return false;
+  if (process.env[GUARD_ENV] === attempt.node) delete process.env[GUARD_ENV];
+  try {
+    const r = runPy(root, 'record.py', [
+      'finish', '--node', attempt.node,
+      '--outcome-json', JSON.stringify(outcome),
+    ]);
+    if (!r.ok) {
+      log(`rsi: node finish failed${r.stderr ? ` (${r.stderr.split('\n').pop()})` : ''}`);
+      return false;
+    }
+    return true;
+  } catch (e) {
+    log(`rsi: node finish skipped (${e && e.message ? e.message : e})`);
+    return false;
+  }
+}
+
+module.exports = {
+  IMPROVE_LANE,
+  GUARD_ENV,
+  attemptsPath,
+  dreamsPath,
+  currentPolicyId,
+  latestNodes,
+  gitSnapshot,
+  gitDelta,
+  engineFromModel,
+  beginAttempt,
+  finishAttempt,
+};

package/lib/runner-command.js

@@ -8,7 +8,7 @@
 // so autonomous runs are reproducible, while keeping explicit per-run/env knobs
 // first in precedence. Precedence: explicit model -> ATRIS_RUNNER_MODEL env ->
 // ATRIS_RUNNER_PROFILE -> legacy ATRIS_CLAUDE_MODEL env -> pinned default.
-const DEFAULT_CLAUDE_RUNNER_MODEL = 'claude-opus-4-8';
+const DEFAULT_CLAUDE_RUNNER_MODEL = 'claude-opus-5-5';
 const DEFAULT_FABLE_RUNNER_MODEL = 'claude-fable-5';
 const DEFAULT_CLAUDE_RUNNER_BIN = 'claude';
 

package/lib/scorecard.js

@@ -245,14 +245,14 @@ function writeScorecard(atrisDir, data) {
 
   // Ensure scorecards.md exists
   if (!fs.existsSync(scorecardsPath)) {
-    const template = `# scorecards.md \u2014 Endgame Results\n\n> Append-only. One line per closed endgame. Records outcome metrics from the horizon.\n\n---\n\n`;
+    const template = `# scorecards.md: Endgame Results\n\n> Append-only. One line per closed endgame. Records outcome metrics from the horizon.\n\n---\n\n`;
     fs.writeFileSync(scorecardsPath, template, 'utf8');
   }
 
-  // Format: - **[date] slug**, shipped: X/Y, wall-clock: Nh, halt: Z%, reward: total, lessons: N
+  // Format: - **[date] slug** - shipped: X/Y - wall-clock: Nh - halt: Z% - reward: total - lessons: N
   const haltPercent = Math.round(haltRatio * 100);
   const wallClockStr = wallClockHours < 1 ? `${Math.round(wallClockHours * 60)}m` : `${wallClockHours.toFixed(1)}h`;
-  const line = `- **[${endDate}] ${slug}** \u2014 shipped: ${tasksShipped}/${tasksAttempted} \u2014 wall-clock: ${wallClockStr} \u2014 halt: ${haltPercent}% \u2014 reward: ${totalReward} \u2014 lessons: ${lessonsGenerated}\n`;
+  const line = `- **[${endDate}] ${slug}** - shipped: ${tasksShipped}/${tasksAttempted} - wall-clock: ${wallClockStr} - halt: ${haltPercent}% - reward: ${totalReward} - lessons: ${lessonsGenerated}\n`;
 
   // Append to file
   fs.appendFileSync(scorecardsPath, line, 'utf8');
@@ -302,7 +302,7 @@ function readScorecards(atrisDir) {
   const scorecards = [];
 
   for (const line of content.split('\n')) {
-    const match = line.match(/^- \*\*\[(.+?)\]\s+(.+?)\*\*\s*\u2014\s*shipped:\s*(\d+)\/(\d+)\s*\u2014\s*wall-clock:\s*(.+?)\s*\u2014\s*halt:\s*(\d+)%\s*\u2014\s*reward:\s*(-?\d+)\s*\u2014\s*lessons:\s*(\d+)$/);
+    const match = line.match(/^- \*\*\[(.+?)\]\s+(.+?)\*\*\s*[-\u2014]\s*shipped:\s*(\d+)\/(\d+)\s*[-\u2014]\s*wall-clock:\s*(.+?)\s*[-\u2014]\s*halt:\s*(\d+)%\s*[-\u2014]\s*reward:\s*(-?\d+)\s*[-\u2014]\s*lessons:\s*(\d+)$/);
     if (!match) continue;
 
     const [, endDate, slug, shipped, attempted, wallClockStr, haltPercent, reward, lessons] = match;

package/lib/sleep-sync.js

@@ -0,0 +1,11 @@
+'use strict';
+
+// Block the current thread for ms milliseconds without burning a core.
+// Atomics.wait parks the thread; a Date.now() loop keeps it at full CPU.
+function sleepSync(ms) {
+  const duration = Math.max(0, Number(ms) || 0);
+  if (!duration) return;
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, duration);
+}
+
+module.exports = { sleepSync };