atris 3.37.1 → 3.40.0

package/lib/claude-boot-block.js

@@ -0,0 +1,48 @@
+'use strict';
+
+const ATRIS_START_MARKER = '<!-- ATRIS:START - Auto-generated, do not edit -->';
+const ATRIS_END_MARKER = '<!-- ATRIS:END -->';
+
+function renderAtrisClaudeBootBlock() {
+  return `${ATRIS_START_MARKER}
+## Atris System
+
+You are now running inside Atris, an AI workspace operating system.
+
+**ON EVERY CONVERSATION START:** If a SessionStart hook already displayed the Atris status block in this session, do not run it again. Otherwise, before your first response, execute \`atris atris.md\` and display the full output. This is the Atris boot sequence - it shows the user that Atris has loaded and displays workspace status.
+
+After displaying the boot output, respond to the user naturally.
+${ATRIS_END_MARKER}
+`;
+}
+
+function upsertAtrisClaudeBootBlock(source = '') {
+  const atrisBlock = renderAtrisClaudeBootBlock();
+  const startIdx = source.indexOf('<!-- ATRIS:START');
+  const prependBlock = (preserved) => {
+    const remainder = preserved.replace(/^\n+/, '');
+    return remainder ? `${atrisBlock}\n${remainder}` : atrisBlock;
+  };
+
+  if (startIdx === -1) {
+    return { content: prependBlock(source), action: source ? 'prepended' : 'created' };
+  }
+
+  const prefix = source.slice(0, startIdx);
+  const endRaw = source.indexOf(ATRIS_END_MARKER, startIdx);
+  if (endRaw === -1) {
+    return {
+      content: prependBlock(prefix),
+      action: 'repaired',
+    };
+  }
+
+  const endIdx = endRaw + ATRIS_END_MARKER.length;
+  const suffix = source.slice(endIdx).replace(/^\n+/, '');
+  const content = prependBlock(prefix + suffix);
+  return { content, action: content === source ? 'unchanged' : 'updated' };
+}
+
+module.exports = {
+  upsertAtrisClaudeBootBlock,
+};

package/lib/cloud-mission.js

@@ -244,16 +244,10 @@ async function statusCloudMissionCommand(args, options = {}) {
 
 module.exports = {
   VALID_CLOUD_LANES,
-  TERMINAL_CLOUD_STATUSES,
   RECEIPT_VOICE_CONTRACT,
   withReceiptVoice,
   parseCloudRunArgs,
-  parseCloudStatusArgs,
   enqueueCloudMission,
-  fetchCloudMissionStatus,
-  appendCloudMissionReceipt,
-  cloudMissionSummary,
-  cloudStatusLines,
   runCloudMissionCommand,
   statusCloudMissionCommand,
 };

package/lib/codex-flight.js

@@ -150,5 +150,4 @@ async function dispatchCodexFlight({ repoPath, slug, brief, verifyCmd, dryRun =
 module.exports = {
   dispatchCodexFlight,
   buildPrompt,
-  parseTaskId,
 };

package/lib/conductor-artifacts.js

@@ -0,0 +1,25 @@
+'use strict';
+
+// Files the conductor itself writes into an agent worktree before the engine runs.
+// They are harness plumbing, not work product, so no dirty-checkout check may
+// count them as dirt. Both the worktree guard and the sealed-review import read
+// this list; keeping it in one place is what stops an engine from being blocked
+// by its own prompt file.
+const CONDUCTOR_UNTRACKED_PATTERN =
+  /^\.atris\/(?:agent-worktree\.json|fleet-prompt-[^/]+\.md|runtime-tmp(?:\/.*)?|state\/briefs\.jsonl)$/;
+
+function isConductorArtifact(file) {
+  return CONDUCTOR_UNTRACKED_PATTERN.test(String(file || ''));
+}
+
+// Accepts a `git status --porcelain` line ("?? .atris/fleet-prompt-BCK-1.md").
+function isConductorStatusLine(line) {
+  const text = String(line || '');
+  if (!text.startsWith('?? ')) return false;
+  return isConductorArtifact(text.slice(3));
+}
+
+module.exports = {
+  isConductorArtifact,
+  isConductorStatusLine,
+};

package/lib/context-gatherer.js

@@ -28,7 +28,13 @@ function hasContextProfile(root = process.cwd()) {
 function compactText(value, max = 160) {
   const text = String(value || '').replace(/\s+/g, ' ').trim();
   if (!text) return '';
-  return text.length > max ? `${text.slice(0, Math.max(0, max - 3)).trim()}...` : text;
+  if (text.length <= max) return text;
+  const slice = text.slice(0, Math.max(0, max - 3));
+  const lastSpace = slice.lastIndexOf(' ');
+  // Cut on a word boundary so a title never ends on half a word ("...an autonomo...").
+  // Fall back to the hard slice only when a single word already fills the limit.
+  const body = lastSpace > 0 ? slice.slice(0, lastSpace) : slice;
+  return `${body.replace(/[\s,;:.!?-]+$/, '')}...`;
 }
 
 function inferDomain(answer) {
@@ -173,6 +179,5 @@ module.exports = {
   renderPrompt,
   starterTaskTitle,
   inferDomain,
-  normalizeQuestionText,
   isAtrisMetaQuestion,
 };

package/lib/deck-compose.js

@@ -137,7 +137,6 @@ function composeSpec(text, opts = {}) {
 
 module.exports = {
   parseBlocks,
-  blocksToSections,
   classify,
   toItem,
   splitQuote,

package/lib/deck-history.js

@@ -56,7 +56,6 @@ function historyFor(query, historyPath = DEFAULT_HISTORY_PATH) {
 }
 
 module.exports = {
-  DEFAULT_HISTORY_PATH,
   specHash,
   recordBuild,
   readHistory,

package/lib/deck-layout.js

@@ -159,11 +159,6 @@ function planLayout(sections, opts = {}) {
 }
 
 module.exports = {
-  BOXED,
-  ONCE,
-  BOXED_BUDGET,
-  DOWNGRADE,
   preferredType,
-  mapToSlide,
   planLayout,
 };

package/lib/deck-review.js

@@ -414,18 +414,11 @@ function confirmReview(presentationId, note = 'visual review passed', outRoot =
 
 module.exports = {
   SCHEMA,
-  RECEIPT_SCHEMA,
   DEFAULT_OUT_ROOT,
-  DEFAULT_RECEIPTS_PATH,
-  AGENT_CHECKLIST,
   CLIP_LIMITS,
-  buildReceipt,
   extractPresentationId,
-  summarizeSlide,
   lintSpec,
-  downloadUrl,
   autoReviewSlides,
   reviewDeck,
-  loadReviewManifest,
   confirmReview,
 };

package/lib/deck-schema.js

@@ -143,7 +143,6 @@ function checkSpec(spec, lintSpec) {
 }
 
 module.exports = {
-  KNOWN_THEMES,
   SLIDE_SCHEMA,
   validateSpec,
   sortFindings,

package/lib/default-verifier.js

@@ -62,8 +62,6 @@ function verifierBudgetWarning(command, env = process.env) {
 }
 
 module.exports = {
-  DEFAULT_MISSION_VERIFIER_TIMEOUT_MS,
-  broadSuiteVerifier,
   missionVerifierTimeoutMs,
   resolveDefaultVerifier,
   verifierBudgetWarning,

package/lib/engine-registry.js

@@ -2,7 +2,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const { spawnSync } = require('child_process');
+const childProcess = require('child_process');
 const {
   RUNNER_PROFILE_DEFS,
   RUNNER_PROFILE_ALIASES,
@@ -13,30 +13,33 @@ const { rankEnginesDetailed, routerPickExplanation } = require('./router-brain')
 const ENGINE_REGISTRY_SCHEMA = 'atris.engine_registry.v2';
 const ENGINE_TIERS = Object.freeze(['fast', 'pro', 'max']);
 const ENGINE_ROLES = Object.freeze(['navigator', 'executor', 'validator']);
+const ENGINE_DUTIES = Object.freeze(['leader', 'errands', 'learning']);
 const ENGINE_HEALTH_STATUSES = Object.freeze(['ready', 'not_installed', 'credit_out', 'error']);
 
 const ENGINE_SEED_META = Object.freeze({
-  'atris-fast': Object.freeze({ tier: 'fast', roles: Object.freeze(['navigator']), fallback_order: 10 }),
-  codex: Object.freeze({ tier: 'pro', roles: Object.freeze(['executor']), fallback_order: 10 }),
-  claude: Object.freeze({ tier: 'max', roles: Object.freeze(['validator', 'executor']), fallback_order: 20 }),
-  cursor: Object.freeze({ tier: 'pro', roles: Object.freeze(['executor']), fallback_order: 30 }),
-  devin: Object.freeze({ tier: 'max', roles: Object.freeze(['executor']), fallback_order: 40 }),
-  grok: Object.freeze({ tier: 'pro', roles: Object.freeze(['executor']), fallback_order: 45 }),
-  fable: Object.freeze({ tier: 'max', roles: Object.freeze(['validator', 'executor']), fallback_order: 50 }),
-  composer: Object.freeze({ tier: 'fast', roles: Object.freeze(['navigator', 'executor']), fallback_order: 60 }),
-  haiku: Object.freeze({ tier: 'fast', roles: Object.freeze(['validator']), fallback_order: 70 }),
-  hermes: Object.freeze({ tier: 'pro', roles: Object.freeze(['executor']), fallback_order: 80 }),
-  droid: Object.freeze({ tier: 'pro', roles: Object.freeze(['executor']), fallback_order: 90 }),
+  'atris-fast': Object.freeze({ tier: 'fast', roles: Object.freeze(['navigator']), models: Object.freeze(['atris fast']), duty: 'learning', fallback_order: 10 }),
+  codex: Object.freeze({ tier: 'pro', roles: Object.freeze(['executor']), models: Object.freeze(['codex']), fallback_order: 10 }),
+  claude: Object.freeze({ tier: 'max', roles: Object.freeze(['validator', 'executor']), models: Object.freeze(['opus 5', 'opus 4.8', 'fable', 'haiku']), fallback_order: 20 }),
+  cursor: Object.freeze({ tier: 'pro', roles: Object.freeze(['executor']), models: Object.freeze(['composer 2.5', 'grok 4.5', 'kimi 3']), fallback_order: 30 }),
+  devin: Object.freeze({ tier: 'max', roles: Object.freeze(['executor']), models: Object.freeze(['built-in router']), duty: 'errands', fallback_order: 40 }),
+  grok: Object.freeze({ tier: 'pro', roles: Object.freeze(['executor']), models: Object.freeze(['grok 4.5']), fallback_order: 45 }),
+  fable: Object.freeze({ tier: 'max', roles: Object.freeze(['validator', 'executor']), models: Object.freeze(['opus 5', 'opus 4.8', 'fable', 'haiku']), duty: 'leader', fallback_order: 50 }),
+  composer: Object.freeze({ tier: 'fast', roles: Object.freeze(['navigator', 'executor']), models: Object.freeze(['composer 2.5']), fallback_order: 60 }),
+  haiku: Object.freeze({ tier: 'fast', roles: Object.freeze(['validator']), models: Object.freeze(['haiku']), fallback_order: 70 }),
+  droid: Object.freeze({ tier: 'pro', roles: Object.freeze(['executor']), models: Object.freeze(['built-in router']), duty: 'errands', fallback_order: 90 }),
 });
 
 function engineRegistryFile(root = process.cwd()) {
   return path.join(root, '.atris', 'state', 'engines.json');
 }
 
+// Machine probe. Routing never calls this on a settled registry: it runs once
+// when an engine first appears (seeding the policy file), at the execution
+// stage right before a spawn, and on the explicit `atris engine doctor`.
 function binInstalled(bin) {
   const safe = String(bin || '').replace(/[^A-Za-z0-9_.-]/g, '');
   if (!safe) return false;
-  const probe = spawnSync('sh', ['-c', `command -v ${safe}`], { encoding: 'utf8' });
+  const probe = childProcess.spawnSync('sh', ['-c', `command -v ${safe}`], { encoding: 'utf8' });
   return probe.status === 0 && Boolean(String(probe.stdout || '').trim());
 }
 
@@ -68,6 +71,18 @@ function normalizeRoles(value, fallback = ['executor']) {
   return filtered.length ? filtered : fallback;
 }
 
+function normalizeModels(value, fallback = []) {
+  const models = Array.isArray(value) ? value.map((model) => String(model || '').trim()) : [];
+  const filtered = models.filter((model, index) => model && models.indexOf(model) === index);
+  return filtered.length ? filtered : fallback;
+}
+
+function normalizeDuty(value, fallback = '') {
+  if (value === undefined) return fallback || '';
+  const duty = String(value || '').trim();
+  return ENGINE_DUTIES.includes(duty) ? duty : '';
+}
+
 function normalizeFallbackOrder(value, fallback) {
   const order = Number(value);
   return Number.isInteger(order) ? order : fallback;
@@ -75,22 +90,32 @@ function normalizeFallbackOrder(value, fallback) {
 
 function normalizeEngineEntry(id, saved = {}) {
   const def = RUNNER_PROFILE_DEFS[id];
-  const seed = ENGINE_SEED_META[id] || { tier: 'pro', roles: ['executor'], fallback_order: 100 };
-  const installed = binInstalled(def.bin);
+  const seed = ENGINE_SEED_META[id] || { tier: 'pro', roles: ['executor'], models: [id], fallback_order: 100 };
   const savedHealth = saved && saved.health && typeof saved.health === 'object' ? saved.health : {};
   const savedStatus = String(savedHealth.status || '').trim();
-  const savedFailure = savedStatus === 'credit_out'
-    || savedStatus === 'error'
-    || (savedStatus === 'not_installed' && Boolean(savedHealth.last_failure_ts));
-  const status = savedFailure ? savedStatus : (installed ? 'ready' : 'not_installed');
+  // Policy over probes: a saved health status is the routing truth, verbatim.
+  // Only an engine the registry has never seen gets one seeding probe; after
+  // that, installed-state changes flow through `atris engine doctor` (or
+  // `atris engine health`), never through the resolve path.
+  let status;
+  let installed;
+  if (ENGINE_HEALTH_STATUSES.includes(savedStatus)) {
+    status = savedStatus;
+    installed = typeof saved.installed === 'boolean' ? saved.installed : status !== 'not_installed';
+  } else {
+    installed = binInstalled(def.bin);
+    status = installed ? 'ready' : 'not_installed';
+  }
   const health = { status };
-  if (savedFailure && savedHealth.last_failure_ts) health.last_failure_ts = String(savedHealth.last_failure_ts);
+  if (status !== 'ready' && savedHealth.last_failure_ts) health.last_failure_ts = String(savedHealth.last_failure_ts);
   return {
     id,
     name: id,
     bin: def.bin,
     tier: normalizeTier(saved.tier, seed.tier),
     roles: normalizeRoles(saved.roles, Array.from(seed.roles)),
+    models: normalizeModels(saved.models, Array.from(seed.models)),
+    duty: normalizeDuty(saved.duty, seed.duty),
     fallback_order: normalizeFallbackOrder(saved.fallback_order, seed.fallback_order),
     installed,
     health,
@@ -118,6 +143,62 @@ function writeEngineRegistry(root, registry) {
   fs.writeFileSync(file, `${JSON.stringify(registry, null, 2)}\n`, 'utf8');
 }
 
+function setEngineOverrides(name, overrides = {}, root = process.cwd()) {
+  const id = canonicalEngineName(name);
+  const knownIds = RUNNER_PROFILE_NAMES.filter((engineId) => ENGINE_SEED_META[engineId]);
+  if (!id || !knownIds.includes(id)) {
+    throw new Error(`Unknown engine "${name}". Known engines: ${knownIds.join(', ')}`);
+  }
+
+  const nextOverrides = {};
+  if (Object.prototype.hasOwnProperty.call(overrides, 'duty')) {
+    const duty = String(overrides.duty || '').trim();
+    if (!ENGINE_DUTIES.includes(duty)) {
+      throw new Error(`Unknown duty "${overrides.duty}". Known duties: ${ENGINE_DUTIES.join(', ')}`);
+    }
+    nextOverrides.duty = duty;
+  }
+  if (Object.prototype.hasOwnProperty.call(overrides, 'models')) {
+    const models = normalizeModels(overrides.models, []);
+    if (!models.length) throw new Error('models must include at least one name');
+    nextOverrides.models = models;
+  }
+  if (!Object.keys(nextOverrides).length) throw new Error('set requires --duty or --models');
+
+  const file = engineRegistryFile(root);
+  const raw = readRawRegistry(file);
+  const savedById = new Map();
+  for (const entry of raw.engines || []) {
+    const savedId = canonicalEngineName(entry && (entry.id || entry.name));
+    if (savedId && knownIds.includes(savedId)) savedById.set(savedId, entry);
+  }
+
+  if (nextOverrides.duty === 'leader' || nextOverrides.duty === 'learning') {
+    for (const engineId of knownIds) {
+      if (engineId === id) continue;
+      const saved = savedById.get(engineId) || {};
+      const effectiveDuty = Object.prototype.hasOwnProperty.call(saved, 'duty')
+        ? normalizeDuty(saved.duty, '')
+        : normalizeDuty(undefined, ENGINE_SEED_META[engineId].duty);
+      if (effectiveDuty === nextOverrides.duty) {
+        savedById.set(engineId, { ...saved, id: engineId, name: engineId, duty: '' });
+      }
+    }
+  }
+
+  const saved = savedById.get(id) || {};
+  savedById.set(id, { ...saved, id, name: id, ...nextOverrides });
+  const ordered = knownIds.map((engineId) => savedById.get(engineId)).filter(Boolean);
+  const next = {
+    ...raw,
+    schema: ENGINE_REGISTRY_SCHEMA,
+    updated_at: new Date().toISOString(),
+    engines: ordered,
+  };
+  writeEngineRegistry(root, next);
+  return { id, ...nextOverrides };
+}
+
 function readEngineRegistry(root = process.cwd(), options = {}) {
   const registry = seededRegistry(root);
   if (options.persist !== false) writeEngineRegistry(root, registry);
@@ -144,7 +225,7 @@ function resolveRegisteredEngine(name, root = process.cwd()) {
   return engine;
 }
 
-function resolveEngineForRole(role, root = process.cwd(), options = {}) {
+function resolveEngineForRoleRanked(role, root = process.cwd(), options = {}) {
   const normalizedRole = String(role || '').trim().toLowerCase();
   if (!ENGINE_ROLES.includes(normalizedRole)) {
     throw new Error(`Unknown role "${role}". Known roles: ${ENGINE_ROLES.join(', ')}`);
@@ -159,12 +240,24 @@ function resolveEngineForRole(role, root = process.cwd(), options = {}) {
   const ranked = rankEnginesDetailed(engines, {
     root,
     taskType: options.taskType || options.task_type || normalizedRole,
+    lowStakes: options.lowStakes,
+    stakes: options.stakes,
   });
-  const selected = ranked.candidates[0] || null;
-  if (selected && process.env.ATRIS_ROUTER_EXPLAIN === '1') {
-    console.error(routerPickExplanation(ranked));
+  return {
+    engine: ranked.candidates[0] || null,
+    reason: routerPickExplanation(ranked),
+    ranked: ranked.candidates,
+  };
+}
+
+function resolveEngineForRole(role, root = process.cwd(), options = {}) {
+  const picked = resolveEngineForRoleRanked(role, root, options);
+  // every pick logs one plain sentence saying which engine won and why;
+  // set ATRIS_ROUTER_EXPLAIN=0 to silence it in quiet contexts.
+  if (picked.engine && picked.reason && process.env.ATRIS_ROUTER_EXPLAIN !== '0') {
+    console.error(picked.reason);
   }
-  return selected;
+  return picked.engine;
 }
 
 function resolveEngineForRoleWithPreference(role, root = process.cwd(), preferredEngineId = '', options = {}) {
@@ -214,19 +307,55 @@ function setEngineHealth(name, status, root = process.cwd()) {
   return engines.find((engine) => engine.id === id);
 }
 
+// Execution-stage guard. Routing hands out engines from policy without ever
+// touching the machine, so the moment we are about to spawn one is where a
+// missing binary has to fail loudly, in one plain sentence naming the binary.
+function requireEngineBin(engineOrId) {
+  const id = typeof engineOrId === 'string'
+    ? canonicalEngineName(engineOrId)
+    : canonicalEngineName(engineOrId && engineOrId.id);
+  const def = RUNNER_PROFILE_DEFS[id];
+  if (!def) {
+    throw new Error(`Unknown engine "${engineOrId && engineOrId.id ? engineOrId.id : engineOrId}". Known engines: ${RUNNER_PROFILE_NAMES.join(', ')}`);
+  }
+  if (!binInstalled(def.bin)) {
+    throw new Error(`${id} CLI (${def.bin}) is not installed here, so this run cannot start.`);
+  }
+  return def.bin;
+}
+
+// The explicit opt-in probe pass: check every engine binary on this machine,
+// fold the result back into the policy file (a ready/not_installed flip only;
+// credit_out and error are operator policy and survive), and report.
+function engineDoctorReport(root = process.cwd()) {
+  const registry = readEngineRegistry(root, { persist: false });
+  const engines = registry.engines.map((engine) => {
+    const installed = binInstalled(engine.bin);
+    let health = engine.health && engine.health.status ? engine.health : { status: installed ? 'ready' : 'not_installed' };
+    if (installed && health.status === 'not_installed') health = { status: 'ready' };
+    if (!installed && health.status === 'ready') health = { status: 'not_installed' };
+    return { ...engine, installed, health };
+  });
+  const next = { ...registry, updated_at: new Date().toISOString(), engines };
+  writeEngineRegistry(root, next);
+  return engines;
+}
+
 module.exports = {
-  ENGINE_REGISTRY_SCHEMA,
-  ENGINE_TIERS,
   ENGINE_ROLES,
+  ENGINE_DUTIES,
   ENGINE_HEALTH_STATUSES,
   engineRegistryFile,
   binInstalled,
   canonicalEngineName,
   readEngineRegistry,
+  requireEngineBin,
+  engineDoctorReport,
   engineRegistryView,
-  registeredEngineIds,
   resolveRegisteredEngine,
+  resolveEngineForRoleRanked,
   resolveEngineForRole,
   resolveEngineForRoleWithPreference,
+  setEngineOverrides,
   setEngineHealth,
 };

package/lib/experiments/daily.js

@@ -618,21 +618,15 @@ function queueList(root, args = []) {
 
 module.exports = {
   SCORECARD_SCHEMA,
-  BENCH_SCHEMA,
   appendQueueEntry,
-  appendResultsTsv,
   appendScorecardRow,
-  areTargetsClean,
   buildScorecardRow,
   evaluateKeepRule,
-  parseBenchResult,
   parseDailyArgs,
-  parseQueueAddArgs,
   pickQueueEntry,
   queueAdd,
   queueList,
   readDailyState,
-  readQueue,
   runApplyScript,
   runBench,
   runDaily,

package/lib/falsifier-probe.js

@@ -0,0 +1,84 @@
+'use strict';
+
+// A check that cannot fail is not a check. `task ready --verify` runs a command
+// and accepts the work on exit 0, which catches a command that fails but never
+// catches one that could not have failed. The 2026-07-26 reward-ledger audit
+// found 131 of 802 accepted proofs carrying nothing falsifiable.
+//
+// The probe: run the same command again in an empty directory, with none of
+// the work present. A check anchored to this codebase fails there. One that
+// passes anywhere - `true`, `echo done`, a check of something outside the
+// repo - passes there too, and proves nothing about the work.
+//
+// Scope, stated plainly: this asks whether a check depends on the codebase at
+// all. It does not ask whether the check exercises the change. `git diff
+// --check` fails in an empty directory and still says nothing about whether
+// the code works, so it clears this probe. The probe raises the floor; it is
+// not a ceiling.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const PROBE_TIMEOUT_MS = 60_000;
+
+// An absolute path reaches back into a real checkout no matter where the
+// command runs, so the empty directory proves nothing about it. Say so rather
+// than reporting a false verdict.
+function absolutePathIn(command) {
+  const match = String(command || '').match(/(?:^|[\s"'`=(])(\/[^\s"'`)]+)/);
+  return match ? match[1] : '';
+}
+
+function probeVerifierCanFail({ command, runner, tmpRoot } = {}) {
+  const cmd = String(command || '').trim();
+  if (!cmd) return { probed: false, canFail: null, reason: 'no command to probe' };
+
+  const absolute = absolutePathIn(cmd);
+  if (absolute) {
+    return {
+      probed: false,
+      canFail: null,
+      reason: `not probed: the command reaches an absolute path (${absolute}), so running it away from this checkout proves nothing`,
+    };
+  }
+
+  const dir = fs.mkdtempSync(path.join(tmpRoot || os.tmpdir(), 'atris-falsifier-probe-'));
+  try {
+    const run = runner || spawnSync;
+    const result = run('bash', ['-lc', cmd], {
+      cwd: dir,
+      encoding: 'utf8',
+      timeout: PROBE_TIMEOUT_MS,
+    });
+    if (result.error) {
+      const timedOut = /ETIMEDOUT/i.test(String(result.error.code || result.error.message || ''));
+      return {
+        probed: false,
+        canFail: null,
+        reason: timedOut
+          ? `not probed: the command ran past ${PROBE_TIMEOUT_MS / 1000}s with none of the work present`
+          : `not probed: the command could not start away from this checkout (${result.error.message})`,
+      };
+    }
+    if (result.status === 0) {
+      return {
+        probed: true,
+        canFail: false,
+        exit: 0,
+        reason: 'this check passes in an empty directory, with none of the work present, so passing here says nothing about the work',
+      };
+    }
+    return {
+      probed: true,
+      canFail: true,
+      exit: result.status,
+      reason: 'this check fails when the work is absent, so passing it means something',
+    };
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+module.exports = { probeVerifierCanFail, absolutePathIn, PROBE_TIMEOUT_MS };