atris 3.53.0 → 3.56.0

package/lib/skill-eval-gate.js

@@ -0,0 +1,249 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+const SKILL_EVAL_SCHEMA = 'atris.skill_eval.v1';
+const SCORECARDS_PATH = path.join('.atris', 'state', 'scorecards.jsonl');
+const BASE_REFS = Object.freeze(['origin/master', 'origin/main', 'master', 'main']);
+
+function runGit(root, args) {
+  try {
+    return spawnSync('git', args, {
+      cwd: root,
+      encoding: 'utf8',
+      timeout: 10000,
+      maxBuffer: 4 * 1024 * 1024,
+    });
+  } catch (error) {
+    return { status: 1, stdout: '', stderr: String(error && error.message ? error.message : error) };
+  }
+}
+
+function normalizedRelativePath(root, value) {
+  const text = String(value || '').trim().replace(/\\/g, '/');
+  if (!text || text.includes('\0') || path.isAbsolute(text)) return null;
+  const absolute = path.resolve(root, text);
+  const relative = path.relative(root, absolute).replace(/\\/g, '/');
+  if (!relative || relative === '..' || relative.startsWith('../')) return null;
+  return relative;
+}
+
+function nulTerminatedPaths(result, root) {
+  if (!result || result.status !== 0) return [];
+  return String(result.stdout || '')
+    .split('\0')
+    .filter(Boolean)
+    .map((entry) => normalizedRelativePath(root, entry))
+    .filter(Boolean);
+}
+
+function resolveBaseRef(root) {
+  const head = runGit(root, ['rev-parse', '--verify', 'HEAD^{commit}']);
+  if (head.status !== 0) return null;
+  for (const ref of BASE_REFS) {
+    const candidate = runGit(root, ['rev-parse', '--verify', `${ref}^{commit}`]);
+    if (candidate.status === 0) return ref;
+  }
+  return null;
+}
+
+function indexMtime(root) {
+  const result = runGit(root, ['rev-parse', '--git-path', 'index']);
+  if (result.status !== 0) return 0;
+  const value = String(result.stdout || '').trim();
+  const file = path.isAbsolute(value) ? value : path.resolve(root, value);
+  try {
+    return fs.statSync(file).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+
+function fileChangeMtime(root, skillPath) {
+  const absolute = path.join(root, skillPath);
+  try {
+    return fs.statSync(absolute).mtimeMs;
+  } catch {
+    try {
+      return fs.statSync(path.dirname(absolute)).mtimeMs;
+    } catch {
+      return 0;
+    }
+  }
+}
+
+function committedChangeMtime(root, baseRef, skillPath) {
+  if (!baseRef) return 0;
+  const result = runGit(root, [
+    'log',
+    '-1',
+    '--format=%cI',
+    `${baseRef}..HEAD`,
+    '--',
+    skillPath,
+  ]);
+  if (result.status !== 0) return 0;
+  const parsed = Date.parse(String(result.stdout || '').trim());
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
+function changedSkillFiles(workspaceRoot = process.cwd()) {
+  const root = path.resolve(workspaceRoot);
+  const inside = runGit(root, ['rev-parse', '--is-inside-work-tree']);
+  if (inside.status !== 0 || String(inside.stdout || '').trim() !== 'true') return [];
+
+  const changes = new Map();
+  const add = (source, paths) => {
+    for (const relative of paths) {
+      if (path.posix.basename(relative) !== 'SKILL.md') continue;
+      const current = changes.get(relative) || new Set();
+      current.add(source);
+      changes.set(relative, current);
+    }
+  };
+
+  add('worktree', nulTerminatedPaths(runGit(root, ['diff', '--name-only', '-z']), root));
+  add('staged', nulTerminatedPaths(runGit(root, ['diff', '--cached', '--name-only', '-z']), root));
+  add('untracked', nulTerminatedPaths(runGit(root, ['ls-files', '--others', '--exclude-standard', '-z']), root));
+
+  const baseRef = resolveBaseRef(root);
+  if (baseRef) {
+    add('committed', nulTerminatedPaths(
+      runGit(root, ['diff', '--name-only', '-z', `${baseRef}...HEAD`]),
+      root,
+    ));
+  }
+
+  const stagedAt = indexMtime(root);
+  return [...changes.entries()]
+    .map(([skillPath, sources]) => {
+      let changedAtMs = 0;
+      if (sources.has('worktree') || sources.has('untracked')) {
+        changedAtMs = Math.max(changedAtMs, fileChangeMtime(root, skillPath));
+      }
+      if (sources.has('staged')) changedAtMs = Math.max(changedAtMs, stagedAt);
+      if (sources.has('committed')) {
+        changedAtMs = Math.max(changedAtMs, committedChangeMtime(root, baseRef, skillPath));
+      }
+      return {
+        path: skillPath,
+        changed_at_ms: changedAtMs,
+        changed_at: changedAtMs > 0 ? new Date(changedAtMs).toISOString() : null,
+        sources: [...sources].sort(),
+      };
+    })
+    .sort((a, b) => a.path.localeCompare(b.path));
+}
+
+function readSkillEvalReceipts(workspaceRoot = process.cwd()) {
+  const root = path.resolve(workspaceRoot);
+  const file = path.join(root, SCORECARDS_PATH);
+  if (!fs.existsSync(file)) return [];
+  const rows = [];
+  for (const line of fs.readFileSync(file, 'utf8').split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const row = JSON.parse(trimmed);
+      if (row && row.schema === SKILL_EVAL_SCHEMA) rows.push(row);
+    } catch {
+      // Foreign and malformed scorecard rows do not prove a skill evaluation.
+    }
+  }
+  return rows;
+}
+
+function hasRubricScores(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const scores = Object.values(value);
+  return scores.length > 0 && scores.every((score) => Number.isFinite(score));
+}
+
+function normalizedIdentity(value) {
+  return String(value || '').trim().toLowerCase();
+}
+
+function validateSkillEvalReceipt(receipt, skill) {
+  if (!receipt || receipt.schema !== SKILL_EVAL_SCHEMA) {
+    return { ok: false, reason: 'wrong_schema' };
+  }
+  if (String(receipt.skill_path || '').replace(/\\/g, '/') !== skill.path) {
+    return { ok: false, reason: 'wrong_skill_path' };
+  }
+  const receiptAtMs = Date.parse(String(receipt.ts || ''));
+  if (!Number.isFinite(receiptAtMs) || receiptAtMs <= Number(skill.changed_at_ms || 0)) {
+    return { ok: false, reason: 'stale_receipt' };
+  }
+  if (receipt.passed !== true) return { ok: false, reason: 'eval_did_not_pass' };
+  if (!hasRubricScores(receipt.rubric_scores)) {
+    return { ok: false, reason: 'rubric_scores_missing' };
+  }
+  const worker = normalizedIdentity(receipt.worker_model);
+  const judge = normalizedIdentity(receipt.judge_identity);
+  if (!worker || !judge) return { ok: false, reason: 'judge_or_worker_missing' };
+  if (worker === judge) return { ok: false, reason: 'judge_matches_worker' };
+  return { ok: true, receipt_at_ms: receiptAtMs };
+}
+
+function skillEvalGate(workspaceRoot = process.cwd()) {
+  const root = path.resolve(workspaceRoot);
+  const skills = changedSkillFiles(root);
+  if (!skills.length) return { ok: true, skipped: true, skills: [] };
+
+  const receipts = readSkillEvalReceipts(root);
+  const missing = [];
+  const accepted = [];
+  for (const skill of skills) {
+    const candidates = receipts.filter((receipt) => (
+      String(receipt.skill_path || '').replace(/\\/g, '/') === skill.path
+    ));
+    const valid = candidates
+      .map((receipt) => ({ receipt, result: validateSkillEvalReceipt(receipt, skill) }))
+      .filter((entry) => entry.result.ok)
+      .sort((a, b) => b.result.receipt_at_ms - a.result.receipt_at_ms)[0];
+    if (valid) {
+      accepted.push({ path: skill.path, receipt_ts: valid.receipt.ts });
+      continue;
+    }
+    const latest = candidates
+      .map((receipt) => ({ receipt, parsed: Date.parse(String(receipt.ts || '')) }))
+      .filter((entry) => Number.isFinite(entry.parsed))
+      .sort((a, b) => b.parsed - a.parsed)[0];
+    const validation = latest ? validateSkillEvalReceipt(latest.receipt, skill) : null;
+    missing.push({
+      path: skill.path,
+      changed_at: skill.changed_at,
+      reason: validation ? validation.reason : 'receipt_missing',
+    });
+  }
+
+  if (!missing.length) return { ok: true, skills, receipts: accepted };
+  const commands = missing.map((entry) => `atris skill eval ${entry.path}`);
+  return {
+    ok: false,
+    reason: 'skill_eval_receipt_required',
+    offenders: missing.map((entry) => entry.path),
+    missing,
+    message: 'a changed skill has no fresh passing evaluation from a judge different from its worker model, so this work cannot land yet.',
+    next_action: commands.length === 1
+      ? `run \`${commands[0]}\`, then re-certify`
+      : `run a fresh skill evaluation for each changed skill, then re-certify: ${commands.join(', ')}`,
+  };
+}
+
+function appendSkillEvalReceipt(workspaceRoot, receipt) {
+  const root = path.resolve(workspaceRoot || process.cwd());
+  const file = path.join(root, SCORECARDS_PATH);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.appendFileSync(file, `${JSON.stringify(receipt)}\n`, 'utf8');
+  return file;
+}
+
+module.exports = {
+  SKILL_EVAL_SCHEMA,
+  appendSkillEvalReceipt,
+  changedSkillFiles,
+  skillEvalGate,
+};

package/lib/task-db.js

@@ -28,6 +28,7 @@ const os = require('os');
 const crypto = require('crypto');
 const { DatabaseSync } = require('node:sqlite');
 const reviewIntegrity = require('./review-integrity');
+const { isGenericScratchRoot } = require('./scratch-root');
 const { isDecisionTask } = require('./task-decision');
 const { parseVerifyCommand } = require('./auto-accept-certified');
 const { taskExplanation } = require('./task-explanation');
@@ -269,6 +270,9 @@ function findWorkspaceRoot(start) {
       if (test(cur)) return cur;
       const parent = path.dirname(cur);
       if (parent === cur) break;
+      // /tmp (and the other first-minute scratch roots) may themselves be a
+      // workspace. A child of that root is a new room and must not inherit it.
+      if (isGenericScratchRoot(parent)) break;
       cur = parent;
     }
     return null;

package/lib/task-proof.js

@@ -8,24 +8,69 @@ const PATH_ONLY_PROOF_RE = /(?:^|[\s'"`])(?:\.{0,2}\/|~\/|\/Users\/|\/private\/|
 const RECEIPT_OR_ARTIFACT_RE = /\b(?:receipt|artifact|screenshot|log|trace|path=|file=|bytes=|model=|opened=|https?:\/\/)\b/i;
 const RESULT_PAIR_RE = /\b(?:typecheck|build|smoke|test|pytest|verifier|validation|validated|verified|render|diff|sync|lineage|projection)\b.{0,80}\b(?:pass|passed|failed|green|ok|exit\s*0|reviewed)\b|\b(?:pass|passed|failed|green|ok|exit\s*0|reviewed)\b.{0,80}\b(?:typecheck|build|smoke|test|pytest|verifier|validation|validated|verified|render|diff|sync|lineage|projection)\b/i;
 const SUITE_GREEN_CLAIM_RE = /\b(?:tests|test\s+suite|suite)\s+(?:is|are|was|were)?\s*(?:all\s+)?(?:green|pass(?:es|ed)?|ok)\b|\b(?:all|full|whole|entire)\s+(?:tests?|test\s+suite|suite)\s+(?:is|are|was|were)?\s*(?:green|pass(?:es|ed)?|ok)\b|\ball\s+green\b|\b(?:npm|pnpm|yarn)\s+(?:run\s+)?test\b\x60?(?:\s+(?:\d+\s*\/\s*\d+|all|suite))?\s+(?:is\s+)?(?:green|pass(?:es|ed)?|ok)\b/i;
-const CI_RUN_CITATION_RE = /https?:\/\/github[.]com\/[^/\s]+\/[^/\s]+\/actions\/runs\/\d+\b|\brun_id\s*=\s*\d+\b|\brun(?:\s+id)?\s*(?:=|:)?\s*\d+\b/i;
+const CI_RUN_URL_RE = /https?:\/\/github[.]com\/[^/\s]+\/[^/\s]+\/actions\/runs\/\d+\b/i;
+const CI_RUN_ID_RE = /\brun_id\s*=\s*\d+\b|\brun(?:\s+id)?\s*(?:=|:)?\s*\d+\b/i;
+const CI_RUN_CITATION_RE = new RegExp(`${CI_RUN_URL_RE.source}|${CI_RUN_ID_RE.source}`, 'i');
 const COMMIT_PINNED_LOCAL_VERIFY_RE = /\bcommit\s+[0-9a-f]{7,40}\b/i;
 const EXIT_ZERO_RE = /\bexit(?:ed)?(?:\s+code)?\s*0\b/i;
-const SUITE_GREEN_CITATION_REASON = 'cite the CI run URL, run id, or commit-pinned verify command with exit 0 before claiming the suite is green';
+const SUITE_GREEN_CITATION_REASON = 'cite a fetched CI run URL (--proof-url with --i-fetched), a run id, or a commit-pinned verify command with exit 0 before claiming the suite is green';
+const LOCAL_SUCCESS_PROOF_EXAMPLE = 'local success example: atris task ready <id> --verify "<cmd>" --result "<plain sentence>" (exit 0 plus the written atris/runs/ receipt path is enough; do not paste a CI URL unless atris fetched it or you pass --proof-url with --i-fetched)';
+const FETCHED_PROOF_URL_RE = /\[(?:fetched|i-fetched)\]\s*https?:\/\/github[.]com\/[^/\s]+\/[^/\s]+\/actions\/runs\/\d+\b/i;
 const HUMAN_PROOF_RE = /\b(?:team human approved|human approved|human approval|approved by|accepted by|reviewed by|customer replied|customer approved|customer accepted|replied)\b/i;
 const FILE_ACTION_RE = /\b(?:changed|updated|edited|created|deleted|saved|wrote|patched|reviewed|verified|validated|opened|read)\b/i;
-const VERIFIED_PROOF_RE = /^\[verified\]\s+`[^`]+`\s+passed\s+\(exit 0\)(?:\s|$)/i;
+const VERIFIED_PROOF_RE = /^\[verified\]\s+`[^`]+`\s+passed\s+\(exit 0\)(?:\s|$)/im;
+const LOCAL_RECEIPT_PATH_RE = /(?:^|[\s])(?:Receipt:\s*)?(?:atris\/runs\/|\.atris\/state\/)[^\s'"`,;)]+\.json\b/i;
 const SECOND_ACTOR_EXECUTED_PROOF_RE = /^Second-actor check:\s+`[^`]+`\s+re-run by [^,]+,\s+exited 0(?:[.\s]|$)/i;
+// Ready/receipt prose may name these. If this process did not run the named
+// command, that sentence is a lie. Keep the list tight: these are the claims
+// that already pass the meaningful-proof floor without executing anything.
+const NAMED_READY_COMMAND_RE = /\b(?:npm test|node --test|git diff --check)\b/i;
+const PROOF_COMMAND_NOT_RUN = 'proof_command_not_run';
 
 function compactWhitespace(text) {
   return String(text || '').replace(/\s+/g, ' ').trim();
 }
 
+function escapeRegExp(text) {
+  return String(text || '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function namedUnrunProofCommand(proof, ranCommand = '') {
+  const text = String(proof || '');
+  const match = text.match(NAMED_READY_COMMAND_RE);
+  if (!match) return '';
+  const named = compactWhitespace(match[0]);
+  const ran = compactWhitespace(ranCommand);
+  if (ran && new RegExp(`\\b${escapeRegExp(named)}\\b`, 'i').test(ran)) return '';
+  return named;
+}
+
+function unrunNamedProofCommandIssue(proof, ranCommand = '') {
+  const named = namedUnrunProofCommand(proof, ranCommand);
+  if (!named) return null;
+  return {
+    reason: PROOF_COMMAND_NOT_RUN,
+    detail: `proof names \`${named}\`, but this process did not run it\nuse --verify "${named}" so the named command actually executes`,
+  };
+}
+
+function hasFetchedCiCitation(text) {
+  return FETCHED_PROOF_URL_RE.test(text);
+}
+
 function hasSuiteGreenCitation(text) {
-  return CI_RUN_CITATION_RE.test(text)
-    || (COMMIT_PINNED_LOCAL_VERIFY_RE.test(text)
-      && COMMAND_PROOF_RE.test(text)
-      && EXIT_ZERO_RE.test(text));
+  // A pasted actions URL is not proof unless atris fetched it (marked
+  // [fetched]/[i-fetched]) or the caller attested with --i-fetched.
+  if (hasFetchedCiCitation(text)) return true;
+  if (CI_RUN_URL_RE.test(text)) return false;
+  if (CI_RUN_ID_RE.test(text)) return true;
+  return COMMIT_PINNED_LOCAL_VERIFY_RE.test(text)
+    && COMMAND_PROOF_RE.test(text)
+    && EXIT_ZERO_RE.test(text);
+}
+
+function hasLocalVerifiedReceipt(text) {
+  return VERIFIED_PROOF_RE.test(text) && LOCAL_RECEIPT_PATH_RE.test(text);
 }
 
 function taskProofState(proof) {
@@ -34,6 +79,18 @@ function taskProofState(proof) {
   if (GENERIC_COMPLETION_PROOF_RE.test(text)) {
     return { ok: false, reason: 'proof must name what was verified, changed, approved, or produced' };
   }
+  // An executed --verify that exited 0 and wrote an atris/runs receipt is
+  // meaningful proof on its own. Suite-green URL rules apply only to claims.
+  if (hasLocalVerifiedReceipt(text)) {
+    return { ok: true, reason: 'proof is a local verified command with receipt path' };
+  }
+  if (CI_RUN_URL_RE.test(text) && !hasFetchedCiCitation(text) && !SUITE_GREEN_CLAIM_RE.test(text)) {
+    return {
+      ok: false,
+      code: 'unfetched_proof_url',
+      reason: 'CI run URLs only count after atris fetches them, or with --proof-url and --i-fetched',
+    };
+  }
   if (SUITE_GREEN_CLAIM_RE.test(text)) {
     if (!hasSuiteGreenCitation(text)) {
       return {
@@ -42,7 +99,7 @@ function taskProofState(proof) {
         reason: SUITE_GREEN_CITATION_REASON,
       };
     }
-    return { ok: true, reason: 'proof cites a CI run or commit-pinned local verify' };
+    return { ok: true, reason: 'proof cites a fetched CI run or commit-pinned local verify' };
   }
   if (COMMAND_PROOF_RE.test(text)) return { ok: true, reason: 'proof names a command' };
   if (HUMAN_PROOF_RE.test(text)) return { ok: true, reason: 'proof names human/customer approval' };
@@ -121,5 +178,9 @@ module.exports = {
   taskProofLooksExecuted,
   taskProofState,
   taskProofExecutionState,
+  namedUnrunProofCommand,
+  unrunNamedProofCommandIssue,
   buildVerifiedProof,
+  LOCAL_SUCCESS_PROOF_EXAMPLE,
+  PROOF_COMMAND_NOT_RUN,
 };

package/lib/verifier-quality.js

@@ -0,0 +1,69 @@
+'use strict';
+
+// Ready/recap need a stronger bar than "command can fail in an empty dir".
+// A bare `test -f` clears the empty-dir probe and still never exercises the
+// change. Allowlist checks that actually run tests, read a symbol, or do a
+// real diff/syntax check.
+
+function classifyVerifier(command) {
+  const cmd = String(command || '').trim();
+  if (!cmd) return { kind: 'empty', ok: false, reason: 'no verifier command' };
+
+  if (/\b(node\s+--test|npm\s+(?:test|run\s+test(?:\S*)?)|pnpm\s+test|yarn\s+test|pytest\b|go\s+test|cargo\s+test|vitest\b|jest\b)\b/i.test(cmd)) {
+    return { kind: 'test_runner', ok: true, reason: 'test runner' };
+  }
+  if (/\b(git\s+diff\s+--(?:check|exit-code|quiet)|node\s+--check)\b/i.test(cmd)) {
+    return { kind: 'diff_check', ok: true, reason: 'diff or syntax check' };
+  }
+  if (/\b(?:rg|grep)\b/i.test(cmd) && /\S{2,}/.test(cmd.replace(/^(?:rg|grep)\b/i, ''))) {
+    return { kind: 'symbol_read', ok: true, reason: 'symbol or content read' };
+  }
+  if (/\batris\s+(?:verify|drill|slop)\b/i.test(cmd)) {
+    return { kind: 'atris_check', ok: true, reason: 'atris check command' };
+  }
+
+  // Bare file/directory existence: passes when the file is there, says nothing
+  // about whether the change works.
+  if (/^(?:test\s+-[efsdL]\s+\S+|\[\s+-[efsdL]\s+\S+\s*\])(?:\s*(?:&&|\|\|)\s*(?:test\s+-[efsdL]\s+\S+|\[\s+-[efsdL]\s+\S+\s*\]))*$/i.test(cmd)
+    || /^test\s+-[efsdL]\s+\S+$/i.test(cmd)
+    || /^\[\s+-[efsdL]\s+\S+\s*\]$/i.test(cmd)) {
+    return {
+      kind: 'file_exists',
+      ok: false,
+      reason: 'file-exists check does not exercise the change; use a test runner, git diff --check, node --check, or rg/grep for a new symbol',
+    };
+  }
+
+  // Unknown commands still need the empty-dir falsifier; allow them through
+  // that probe. Only bare file-exists is rejected here as not exercising work.
+  return {
+    kind: 'unknown',
+    ok: true,
+    reason: 'custom verifier; empty-dir falsifier still applies',
+  };
+}
+
+function isRealTestRunnerProof(proof) {
+  const flat = String(proof || '').replace(/\s+/g, ' ').trim();
+  if (!flat) return false;
+  return /\b(node\s+--test|npm\s+(?:test|run\s+test(?:\S*)?)|pnpm\s+test|yarn\s+test|pytest\b|go\s+test|cargo\s+test|vitest\b|jest\b)\b/i.test(flat)
+    && /\b(pass|passed|green|ok|0 failures?|\d+\/\d+)\b/i.test(flat);
+}
+
+function quoteVerifierCommand(proof) {
+  const flat = String(proof || '').replace(/\s+/g, ' ').trim();
+  if (!flat) return null;
+  const verified = flat.match(/\[verified\]\s*`([^`]+)`\s*passed/i);
+  if (verified) return verified[1].trim();
+  const backticked = flat.match(/`([^`]+)`/);
+  if (backticked && /\b(test|npm|node|git|rg|grep|pytest|vitest|jest)\b/i.test(backticked[1])) {
+    return backticked[1].trim();
+  }
+  return null;
+}
+
+module.exports = {
+  classifyVerifier,
+  isRealTestRunnerProof,
+  quoteVerifierCommand,
+};

package/lib/wish-audit.js

@@ -1047,13 +1047,13 @@ function auditWish(text, root = process.cwd(), options = {}) {
   } catch {
     validator = null;
   }
-  if (!executor) {
+  if (!executor && !options.cloudRun) {
     const question = 'Which working builder should handle this?';
     const answered = answeredRepeatedQuestionValue(text, root, question, 'builder');
     if (answered) executor = { id: slugify(answered), name: answered };
     else questions.push(question);
   }
-  if (!validator) {
+  if (!validator && !options.cloudRun) {
     const question = 'Which working reviewer should validate it?';
     const answered = answeredRepeatedQuestionValue(text, root, question, 'reviewer');
     if (answered) validator = { id: slugify(answered), name: answered };

package/lib/wish-delegate.js

@@ -1639,9 +1639,18 @@ function applyAnswer(wish, answer, root, options = {}) {
     answers: [...(wish.answers || []), answer],
   };
   const auditText = [wish.text, ...(answeredWish.answers || [])].join(' ');
-  const audited = auditWish(auditText, root, { engineOverride, originalText: wish.text });
+  // A cloud grant runs on the backend, so it never needs a local builder or
+  // reviewer; only clarity questions still apply.
+  const cloudRun = typeof options.cloudDispatch === 'function';
+  const audited = auditWish(auditText, root, { engineOverride, originalText: wish.text, cloudRun });
   const audit = bestGuessAfterRepeatedQuestion(answeredWish, audited, root);
   if (!audit.ok) return askForInput(answeredWish, audit, root, asJson);
+  // --cloud grants hand the answered wish to the backend instead of a local
+  // engine. The caller supplies the dispatcher so this file stays free of the
+  // cloud client.
+  if (typeof options.cloudDispatch === 'function') {
+    return options.cloudDispatch(answeredWish, auditText, root);
+  }
   if (noMission) return captureOnlyWish(answeredWish, audit, root, asJson);
   return delegateWish(answeredWish, audit, root, asJson, { oneLap: wish.one_lap === true });
 }