atris 3.46.0 → 3.47.0

package/atris/skills/design/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: design
 description: Frontend aesthetics policy. Use when building UI, components, landing pages, dashboards, or any frontend work. Prevents generic ai-generated look.
-version: 3.1.0
+version: 3.1.1
 allowed-tools: Read, Write, Edit, Bash, Glob
 tags:
   - design
@@ -112,6 +112,7 @@ Every entry: id, rule, detector, status. A detector is a regex/command a gate ca
 | D11 | layout contracts, not dioramas: min-height over fixed height, fluid max-width over fixed px, every overflow reachable (scroll or +N more), stress-test with hostile content before shipping | judgment | active |
 | D12 | one accent moment per card: brand accent for the primary action only, gold for confidence/progress fills, green only for completed; everything else tonal | judgment | active |
 | D13 | motion is calm and eased: 120-300ms ease-out on opacity/transform only, loops match a measured source cadence, prefers-reduced-motion always freezes them | judgment | active |
+| D14 | compact selectors lead with the chosen name and a discriminating icon; remove redundant field labels and visible type explanations when icon, title, and accessible label carry them | judgment | active |
 
 Measured recipes live in the mimic studies: `~/arena/mimic-beautiful-ui/LESSONS.md` (18 AI-interface components with exact tokens) and its `remix.css` :root block (the portable Atris token sheet, coffee + paper themes). Start there before designing an agent surface.
 

package/commands/ci.js

@@ -14,7 +14,7 @@ function showCiHelp() {
   console.log('atris ci runs github actions jobs on this machine with a warm local work folder.');
   console.log('change runs-on: ubuntu-latest to runs-on: atris.');
   console.log('a GITHUB_TOKEN or an authenticated gh cli is required.');
-  console.log('usage: atris ci runner --repo <owner/name> [--label <name>] [--once]');
+  console.log('usage: atris ci runner --repo <owner/name> [--repo <owner/name> ...] [--label <name>] [--once]');
   console.log('       atris ci usage [--repo <owner/name>]');
 }
 

package/commands/close.js

@@ -1,6 +1,7 @@
 const crypto = require('crypto');
 const fs = require('fs');
 const path = require('path');
+const { spawnSync } = require('child_process');
 const { knownCommands } = require('../lib/known-commands');
 const { readUsage, usagePath } = require('../lib/usage');
 const pulse = require('../lib/pulse');
@@ -16,6 +17,12 @@ const EXPERIMENTS_RELATIVE_PATH = path.join('.atris', 'state', 'experiments.json
 const EXPERIMENTS_DIR_RELATIVE_PATH = path.join('atris', 'experiments');
 const RESOLVED_IN_SOURCE_PROOF = 'resolved in source store';
 const FAILED_TASK_BATCH_PREFIX = 'tasks:failed:';
+// Live-probe incidents: a diagnosis may only be recorded alongside a command
+// that fails right now, and may only close after that command passes twice
+// with a real gap between runs (catches the bug that comes back hours later).
+const PROBE_TIMEOUT_MS = 60 * 1000;
+const PROBE_HOLD_GAP_MS = 60 * 60 * 1000;
+const PROBE_STOP_AFTER_FAILED_CHECKS = 2;
 
 function ledgerPath(cwd = process.cwd()) {
   return path.join(cwd, LEDGER_RELATIVE_PATH);
@@ -111,6 +118,8 @@ function foldEvents(events, options = {}) {
         ttl_days: Number(event.ttl_days) || 7,
         close_condition: normalizeSpaces(event.close_condition || 'the loop is resolved'),
         source: normalizeSpaces(event.source || 'manual'),
+        probe: normalizeSpaces(event.probe || '') || null,
+        probe_runs: [],
         status: 'open',
         closed_at: null,
         dissolved_at: null,
@@ -138,6 +147,12 @@ function foldEvents(events, options = {}) {
     } else if (event.kind === 'escalated') {
       const day = event.day || (event.at ? String(event.at).slice(0, 10) : null);
       if (day && !flag.escalated_days.includes(day)) flag.escalated_days.push(day);
+    } else if (event.kind === 'probed') {
+      flag.probe_runs.push({
+        at: eventTime(event),
+        pass: !!event.pass,
+        exit_code: Number.isFinite(event.exit_code) ? event.exit_code : null,
+      });
     }
   }
 
@@ -161,9 +176,49 @@ function withComputedState(flag, now = new Date()) {
     days_old: daysOld,
     days_past_ttl: daysPastTtl,
     overdue,
+    ...probeState(flag),
   };
 }
 
+// Probe state from recorded runs. 'failing' until a check passes, 'passed
+// once' until a second pass lands PROBE_HOLD_GAP_MS later, then 'holding'
+// (eligible to close). failed_checks counts re-checks that still failed:
+// each one is a fix attempt that did not move reality.
+function probeState(flag) {
+  if (!flag.probe) {
+    return { probe_status: null, failed_checks: 0, probe_holding: false };
+  }
+  const runs = flag.probe_runs || [];
+  const failedChecks = runs.filter((run) => !run.pass).length;
+
+  const trailing = [];
+  for (let index = runs.length - 1; index >= 0 && runs[index].pass; index -= 1) {
+    trailing.unshift(runs[index]);
+  }
+
+  let status = 'failing';
+  let holding = false;
+  if (trailing.length >= 1) {
+    const firstMs = parseDate(trailing[0].at) || 0;
+    const lastMs = parseDate(trailing[trailing.length - 1].at) || 0;
+    holding = trailing.length >= 2 && lastMs - firstMs >= PROBE_HOLD_GAP_MS;
+    status = holding ? 'holding' : 'passed once';
+  }
+  return { probe_status: status, failed_checks: failedChecks, probe_holding: holding };
+}
+
+function runProbe(command, context = {}) {
+  const result = spawnSync(command, {
+    shell: true,
+    cwd: context.cwd || process.cwd(),
+    timeout: PROBE_TIMEOUT_MS,
+    stdio: ['ignore', 'pipe', 'pipe'],
+    encoding: 'utf8',
+  });
+  const exitCode = typeof result.status === 'number' ? result.status : 1;
+  return { pass: exitCode === 0, exit_code: exitCode };
+}
+
 function openFlags(cwd = process.cwd(), options = {}) {
   return foldEvents(readEvents(cwd), options).filter((flag) => flag.status === 'open');
 }
@@ -202,6 +257,7 @@ function listLine(flag) {
     flag.what.toLowerCase(),
     `${formatDays(flag.days_old)} old`,
   ];
+  if (flag.probe) parts.push(`probe ${flag.probe_status}`);
   if (flag.overdue) {
     parts.push(`${formatDays(flag.days_past_ttl)} past ttl`);
   }
@@ -269,10 +325,11 @@ function publicFlag(flag) {
 }
 
 function printHelp() {
-  console.log('usage: atris close <add|list|done|dissolve|snooze|sweep|scan>');
-  console.log('add "<what>" [--owner x] [--lane life|business|code] [--ttl 7] [--when "<condition>"] [--source y]');
+  console.log('usage: atris close <add|list|done|dissolve|snooze|sweep|scan|check>');
+  console.log('add "<what>" [--owner x] [--lane life|business|code] [--ttl 7] [--when "<condition>"] [--source y] [--probe "<cmd that fails now>"]');
   console.log('list [--json] [--lane x]');
-  console.log('done <id> [--proof "..."]');
+  console.log('done <id> [--proof "..."]  (a probed incident closes only after its probe holds)');
+  console.log('check [id] [--json]  (run live probes; failing probe = old theory still live)');
   console.log('dissolve <id> --why "..."');
   console.log('snooze <id> --days n');
   console.log('sweep [--json]');
@@ -295,6 +352,20 @@ function commandAdd(args, context = {}) {
     return 0;
   }
 
+  // A probe turns the flag into a live incident: the claim in `what` is only
+  // recordable while the probe command fails. A passing probe means there is
+  // nothing to diagnose, so refuse instead of storing a story.
+  if (options.probe === true) throw new Error('--probe needs a command');
+  const probe = normalizeSpaces(options.probe || '');
+  let probeExit = null;
+  if (probe) {
+    const result = (context.runProbe || runProbe)(probe, context);
+    if (result.pass) {
+      throw new Error('probe passes right now; an incident needs a command that currently fails. fix the probe or drop --probe');
+    }
+    probeExit = result.exit_code;
+  }
+
   const openedAt = now.toISOString();
   const event = {
     kind: 'opened',
@@ -308,11 +379,88 @@ function commandAdd(args, context = {}) {
     close_condition: normalizeSpaces(options.when || 'the loop is resolved'),
     source: normalizeSpaces(options.source || 'manual'),
   };
+  if (probe) event.probe = probe;
   appendEvent(event, context.cwd);
-  console.log(`opened ${event.id}`);
+  if (probe) {
+    console.log(`opened ${event.id}, probe failing as required (exit ${probeExit})`);
+  } else {
+    console.log(`opened ${event.id}`);
+  }
   return 0;
 }
 
+// atris close check [id] — run the live probes on open incidents. This is the
+// first move for any session entering an area: if a probe still fails, the
+// recorded theory is still live; do not diagnose fresh. After
+// PROBE_STOP_AFTER_FAILED_CHECKS failing re-checks the verdict is automatic:
+// stop and tell the human.
+function commandCheck(args, context = {}) {
+  const { positional, options } = parseArgs(args);
+  const id = positional[0] || null;
+  const now = context.now ? new Date(context.now) : new Date();
+
+  let flags = openFlags(context.cwd, { now }).filter((flag) => flag.probe);
+  if (id) {
+    flags = flags.filter((flag) => flag.id === id);
+    if (flags.length === 0) throw new Error(`${id} is not an open incident with a probe`);
+  }
+  if (flags.length === 0) {
+    console.log('no open incidents with probes.');
+    return 0;
+  }
+
+  const results = [];
+  for (const flag of flags) {
+    const run = (context.runProbe || runProbe)(flag.probe, context);
+    appendEvent({
+      kind: 'probed',
+      at: now.toISOString(),
+      id: flag.id,
+      pass: run.pass,
+      exit_code: run.exit_code,
+    }, context.cwd);
+    results.push({ id: flag.id, what: flag.what, ...run });
+  }
+
+  const after = new Map(
+    openFlags(context.cwd, { now }).map((flag) => [flag.id, flag])
+  );
+
+  if (options.json) {
+    printJson({
+      checked: results.map((result) => {
+        const flag = after.get(result.id);
+        return {
+          ...result,
+          probe_status: flag ? flag.probe_status : null,
+          failed_checks: flag ? flag.failed_checks : null,
+        };
+      }),
+    });
+    return 0;
+  }
+
+  let anyFailing = false;
+  for (const result of results) {
+    const flag = after.get(result.id);
+    if (result.pass) {
+      if (flag && flag.probe_holding) {
+        console.log(`${result.id}: probe held. close it: atris close done ${result.id}`);
+      } else {
+        console.log(`${result.id}: probe passed once. re-check in an hour to confirm it holds.`);
+      }
+      continue;
+    }
+    anyFailing = true;
+    const failedChecks = flag ? flag.failed_checks : 0;
+    console.log(`${result.id}: probe still failing (exit ${result.exit_code}). the recorded theory is still live.`);
+    if (failedChecks >= PROBE_STOP_AFTER_FAILED_CHECKS) {
+      console.log(`${result.id}: ${failedChecks} fix attempts have not moved the probe. stop and tell the human.`);
+    }
+  }
+  return anyFailing ? 1 : 0;
+}
+
 function commandList(args, context = {}) {
   const { options } = parseArgs(args);
   const lane = options.lane ? String(options.lane).toLowerCase() : null;
@@ -346,13 +494,25 @@ function commandDone(args, context = {}) {
   const { positional, options } = parseArgs(args);
   const id = positional[0];
   if (!id) throw new Error('id is required');
-  requireOpenFlag(id, context);
+  const flag = requireOpenFlag(id, context);
+
+  // An incident with a live probe closes on held evidence, not on a claim:
+  // the probe must pass twice, an hour apart, so the storm that returns
+  // hours later cannot be marked solved in the same breath as the fix.
+  if (flag.probe && !flag.probe_holding) {
+    if (flag.probe_status === 'failing') {
+      throw new Error(`probe still fails; run the fix, then: atris close check ${id}`);
+    }
+    throw new Error(`probe passed once; confirm it holds with atris close check ${id} at least an hour after the first pass`);
+  }
+
   const at = (context.now ? new Date(context.now) : new Date()).toISOString();
+  const defaultProof = flag.probe ? `probe held: ${flag.probe}` : '';
   appendEvent({
     kind: 'closed',
     at,
     id,
-    proof: normalizeSpaces(options.proof || ''),
+    proof: normalizeSpaces(options.proof || defaultProof),
   }, context.cwd);
   console.log(`closed ${id}`);
   return 0;
@@ -1097,6 +1257,7 @@ function run(args = [], context = {}) {
     if (subcommand === 'snooze') return commandSnooze(rest, context);
     if (subcommand === 'sweep') return commandSweep(rest, context);
     if (subcommand === 'scan') return commandScan(rest, context);
+    if (subcommand === 'check') return commandCheck(rest, context);
     console.error(`unknown close command: ${subcommand}`);
     return 2;
   } catch (error) {

package/lib/ci-runner.js

@@ -25,6 +25,14 @@ function clockDate(clock) {
   return date;
 }
 
+function parseRunnerMarker(line) {
+  const text = String(line);
+  if (text.includes('Running job:')) return { type: 'start' };
+  const completed = text.match(/completed with result:\s*([a-z]+)/i);
+  if (completed) return { type: 'complete', result: completed[1].toLowerCase() };
+  return null;
+}
+
 function runnerAssetName(platform, arch, version = RUNNER_VERSION) {
   const platformNames = { darwin: 'osx', linux: 'linux' };
   const archNames = { x64: 'x64', arm64: 'arm64' };
@@ -53,14 +61,19 @@ function parseRepo(value) {
 
 function parseRunnerArgs(argv) {
   const options = { label: null, once: false };
-  let repoValue = null;
+  const repos = [];
+  const seenRepos = new Set();
 
   for (let index = 0; index < argv.length; index += 1) {
     const arg = argv[index];
     if (arg === '--repo') {
-      if (repoValue !== null) throw new Error('--repo may only be set once');
-      repoValue = argv[index + 1];
+      const repoValue = argv[index + 1];
       if (!repoValue || repoValue.startsWith('--')) throw new Error('--repo owner/name is required');
+      const repo = parseRepo(repoValue);
+      const key = repo.slug.toLowerCase();
+      if (seenRepos.has(key)) throw new Error(`duplicate --repo: ${repo.slug}`);
+      seenRepos.add(key);
+      repos.push(repo);
       index += 1;
     } else if (arg === '--label') {
       if (options.label !== null) throw new Error('--label may only be set once');
@@ -78,7 +91,8 @@ function parseRunnerArgs(argv) {
     }
   }
 
-  return { repo: parseRepo(repoValue), label: options.label, once: options.once };
+  if (repos.length === 0) throw new Error('--repo owner/name is required');
+  return { repos, label: options.label, once: options.once };
 }
 
 function parseUsageArgs(argv) {
@@ -143,6 +157,11 @@ function summarizeUsage(records, options = {}) {
     const repo = repos.get(record.repo) || { repo: record.repo, jobs: 0, minutes: 0 };
     repo.jobs += 1;
     repo.minutes += minutes;
+    if (typeof record.result === 'string' && /^[a-z]+$/i.test(record.result)) {
+      if (!repo.results) repo.results = {};
+      const result = record.result.toLowerCase();
+      repo.results[result] = (repo.results[result] || 0) + 1;
+    }
     repos.set(record.repo, repo);
   }
 
@@ -161,10 +180,25 @@ function formatUsageSummary(summary) {
     `total minutes: ${summary.totalMinutes}`,
     `minutes this month: ${summary.monthMinutes}`,
     'per repo:',
-    ...summary.repos.map((repo) => (
-      `${repo.repo}: ${repo.jobs} ${repo.jobs === 1 ? 'job' : 'jobs'}, `
-      + `${repo.minutes} ${repo.minutes === 1 ? 'minute' : 'minutes'}`
-    )),
+    ...summary.repos.map((repo) => {
+      const resultOrder = ['succeeded', 'failed', 'cancelled', 'skipped'];
+      const results = repo.results
+        ? Object.entries(repo.results).sort(([left], [right]) => {
+          const leftIndex = resultOrder.indexOf(left);
+          const rightIndex = resultOrder.indexOf(right);
+          if (leftIndex !== -1 || rightIndex !== -1) {
+            return (leftIndex === -1 ? resultOrder.length : leftIndex)
+              - (rightIndex === -1 ? resultOrder.length : rightIndex);
+          }
+          return left.localeCompare(right);
+        })
+        : [];
+      return [
+        `${repo.repo}: ${repo.jobs} ${repo.jobs === 1 ? 'job' : 'jobs'}`,
+        ...results.map(([result, count]) => `${count} ${result}`),
+        `${repo.minutes} ${repo.minutes === 1 ? 'minute' : 'minutes'}`,
+      ].join(', ');
+    }),
   ].join('\n');
 }
 
@@ -314,21 +348,130 @@ async function ensureRunner(options = {}) {
   return runnerDir;
 }
 
-function runWorker(runnerDir, jitConfig, start = spawn) {
+function linkRunnerTree(source, destination) {
+  fs.mkdirSync(destination, { recursive: true });
+  for (const entry of fs.readdirSync(source, { withFileTypes: true })) {
+    const sourcePath = path.join(source, entry.name);
+    const destinationPath = path.join(destination, entry.name);
+    if (fs.existsSync(destinationPath)) continue;
+    if (entry.isDirectory()) {
+      linkRunnerTree(sourcePath, destinationPath);
+    } else if (entry.isSymbolicLink()) {
+      fs.symlinkSync(fs.readlinkSync(sourcePath), destinationPath);
+    } else {
+      try {
+        fs.linkSync(sourcePath, destinationPath);
+      } catch (error) {
+        if (!error || error.code !== 'EXDEV') throw error;
+        fs.copyFileSync(sourcePath, destinationPath);
+      }
+    }
+  }
+}
+
+function ensureRepoRunnerDirectory(runnerDir, repo) {
+  const destination = path.join(runnerDir, 'repos', repo.owner.toLowerCase(), repo.repo.toLowerCase());
+  if (fs.existsSync(path.join(destination, 'run.sh'))) return destination;
+  fs.mkdirSync(destination, { recursive: true });
+  const ignored = new Set([
+    '.credentials',
+    '.credentials_rsaparams',
+    '.runner',
+    '.service',
+    '_diag',
+    '_work',
+    'repos',
+  ]);
+  for (const entry of fs.readdirSync(runnerDir, { withFileTypes: true })) {
+    if (ignored.has(entry.name)) continue;
+    const sourcePath = path.join(runnerDir, entry.name);
+    const destinationPath = path.join(destination, entry.name);
+    if (fs.existsSync(destinationPath)) continue;
+    if (entry.isDirectory()) {
+      linkRunnerTree(sourcePath, destinationPath);
+    } else if (entry.isSymbolicLink()) {
+      fs.symlinkSync(fs.readlinkSync(sourcePath), destinationPath);
+    } else {
+      try {
+        fs.linkSync(sourcePath, destinationPath);
+      } catch (error) {
+        if (!error || error.code !== 'EXDEV') throw error;
+        fs.copyFileSync(sourcePath, destinationPath);
+      }
+    }
+  }
+  if (!fs.existsSync(path.join(destination, 'run.sh'))) {
+    throw new Error('github actions runner cache did not contain run.sh');
+  }
+  return destination;
+}
+
+function forwardRunnerStream(stream, output, prefix, inspectLine) {
+  if (!stream) return;
+  let pending = '';
+  stream.setEncoding('utf8');
+  stream.on('data', (chunk) => {
+    pending += chunk;
+    let newline = pending.indexOf('\n');
+    while (newline !== -1) {
+      const line = pending.slice(0, newline).replace(/\r$/, '');
+      pending = pending.slice(newline + 1);
+      inspectLine(line);
+      output.write(`${prefix}${line}\n`);
+      newline = pending.indexOf('\n');
+    }
+  });
+  stream.on('end', () => {
+    if (!pending) return;
+    const line = pending.replace(/\r$/, '');
+    inspectLine(line);
+    output.write(`${prefix}${line}`);
+  });
+}
+
+function runWorker(runnerDir, jitConfig, options = {}) {
   return new Promise((resolve, reject) => {
-    const child = start('./run.sh', ['--jitconfig', jitConfig], {
+    const clock = options.clock || (() => new Date());
+    const child = (options.start || spawn)('./run.sh', ['--jitconfig', jitConfig], {
       cwd: runnerDir,
       env: process.env,
-      stdio: 'inherit',
+      stdio: ['inherit', 'pipe', 'pipe'],
     });
-    child.on('error', reject);
-    child.on('exit', (code, signal) => {
+    let startedAt = null;
+    let finishedAt = null;
+    let result = null;
+    let settled = false;
+    const measurement = () => ({ startedAt, finishedAt, result });
+    const inspectLine = (line) => {
+      const marker = parseRunnerMarker(line);
+      if (!marker) return;
+      if (marker.type === 'start' && !startedAt) startedAt = clockDate(clock);
+      if (marker.type === 'complete' && !finishedAt) {
+        finishedAt = clockDate(clock);
+        result = marker.result;
+      }
+    };
+    forwardRunnerStream(child.stdout, options.stdout || process.stdout, options.prefix || '', inspectLine);
+    forwardRunnerStream(child.stderr, options.stderr || process.stderr, options.prefix || '', inspectLine);
+    child.on('error', (error) => {
+      if (settled) return;
+      settled = true;
+      error.ciUsage = measurement();
+      reject(error);
+    });
+    child.on('close', (code, signal) => {
+      if (settled) return;
+      settled = true;
       if (code === 0) {
-        resolve();
+        resolve(measurement());
       } else if (signal) {
-        reject(new Error(`github actions runner stopped with signal ${signal}`));
+        const error = new Error(`github actions runner stopped with signal ${signal}`);
+        error.ciUsage = measurement();
+        reject(error);
       } else {
-        reject(new Error(`github actions runner exited with code ${code}`));
+        const error = new Error(`github actions runner exited with code ${code}`);
+        error.ciUsage = measurement();
+        reject(error);
       }
     });
   });
@@ -348,20 +491,39 @@ async function runJobLoop(options, dependencies = {}) {
     const runnerName = `${options.runnerName}-${completedJobs + 1}`;
     const jitConfig = await mint(options.token, options.repo, options.label, runnerName);
     log(`worker ready, waiting for jobs on ${options.repo.slug}`);
-    const startedAt = clockDate(clock);
     let workerError = null;
+    let workerUsage = null;
     try {
-      await startWorker(options.runnerDir, jitConfig);
+      workerUsage = await startWorker(options.runnerDir, jitConfig, {
+        clock,
+        prefix: options.logPrefix || '',
+        start: dependencies.spawn,
+        stderr: dependencies.stderr,
+        stdout: dependencies.stdout,
+      });
     } catch (error) {
       workerError = error;
+      workerUsage = error && error.ciUsage;
     } finally {
-      const finishedAt = clockDate(clock);
-      const durationSeconds = Math.max(0, Math.ceil((finishedAt.getTime() - startedAt.getTime()) / 1000));
-      const line = `${JSON.stringify({
+      const markerStart = workerUsage && workerUsage.startedAt
+        ? clockDate(() => workerUsage.startedAt)
+        : null;
+      const markerFinish = workerUsage && workerUsage.finishedAt
+        ? clockDate(() => workerUsage.finishedAt)
+        : null;
+      const startedAt = markerStart || markerFinish || clockDate(clock);
+      const durationSeconds = markerStart && markerFinish
+        ? Math.max(0, Math.ceil((markerFinish.getTime() - markerStart.getTime()) / 1000))
+        : 0;
+      const record = {
         repo: options.repo.slug,
         started_at: startedAt.toISOString(),
         duration_seconds: durationSeconds,
-      })}\n`;
+      };
+      if (workerUsage && typeof workerUsage.result === 'string') {
+        record.result = workerUsage.result.toLowerCase();
+      }
+      const line = `${JSON.stringify(record)}\n`;
       await appendUsage(file, line);
     }
     if (workerError) throw workerError;
@@ -374,18 +536,42 @@ async function runCiRunner(options, dependencies = {}) {
   const token = (dependencies.resolveGithubToken || resolveGithubToken)();
   const runnerDir = await (dependencies.ensureRunner || ensureRunner)({ log: dependencies.log });
   const host = String((dependencies.hostname || os.hostname)()).toLowerCase().replace(/[^a-z0-9-]+/g, '-');
-  return runJobLoop({
-    ...options,
-    token,
-    runnerDir,
-    runnerName: `atris-${host || 'worker'}-${process.pid}`,
-  }, dependencies);
+  const log = dependencies.log || console.log;
+  const prepare = dependencies.ensureRepoRunnerDirectory || ensureRepoRunnerDirectory;
+  const startLoop = dependencies.runJobLoop || runJobLoop;
+  const manyRepos = options.repos.length > 1;
+  const loops = options.repos.map((repo, index) => (async () => {
+    const repoRunnerDir = await prepare(runnerDir, repo);
+    const repoLog = manyRepos ? (line) => log(`${repo.slug}: ${line}`) : log;
+    return startLoop({
+      ...options,
+      repo,
+      token,
+      runnerDir: repoRunnerDir,
+      runnerName: `atris-${host || 'worker'}-${process.pid}-${index + 1}`,
+      logPrefix: manyRepos ? `${repo.slug}: ` : '',
+    }, { ...dependencies, log: repoLog });
+  })());
+  const settled = await Promise.allSettled(loops);
+  const failures = settled
+    .map((outcome, index) => ({ outcome, repo: options.repos[index] }))
+    .filter(({ outcome }) => outcome.status === 'rejected');
+  for (const failure of failures) {
+    const detail = String(failure.outcome.reason?.message || failure.outcome.reason || 'runner loop failed')
+      .replace(/\s+/g, ' ')
+      .trim();
+    log(`${failure.repo.slug}: ${detail.toLowerCase()}`);
+  }
+  if (failures.length > 0) {
+    throw new Error(`${failures.length} ci runner ${failures.length === 1 ? 'loop' : 'loops'} failed`);
+  }
+  return settled.reduce((total, outcome) => total + outcome.value, 0);
 }
 
 module.exports = {
-  appendUsageLine,
   buildJitConfigRequest,
   formatUsageSummary,
+  parseRunnerMarker,
   parseRunnerArgs,
   parseUsageArgs,
   readUsageRecords,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.46.0",
+  "version": "3.47.0",
   "description": "you say what you want in plain words. atris builds it, checks it, and shows you proof.",
   "main": "bin/atris.js",
   "bin": {