@hone-ai/cli 1.41.0 → 1.42.0

package/lib/review-diff-check.js

@@ -0,0 +1,262 @@
+'use strict';
+/**
+ * review-diff-check.js — HC-GF-390-followup-1: does the stored review diff describe HEAD?
+ *
+ * HC-GF-390 stores, beside step_4's artifact, the CLI-reported diff against HEAD of each over-cap file the build
+ * changed, and the reviewers read "a region with no hunk is unchanged from HEAD". The server can vet a section's
+ * post-image against the stored build, but it has no repository, so it cannot vet the pre-image, the hunk offsets or
+ * the context lines. `hone verify-patch` has the clone: this re-derives each stored section from HEAD and reports
+ * whether it holds. The server renders a mismatch as withheld, so a forged region is never shown as "unchanged".
+ *
+ * Per section, stopping at the first failure:
+ *   parse       the strict grammar `git diff --full-index` prints for a text modification, and nothing else
+ *   pre_image   the `index` pre-image id is HEAD's blob for that path
+ *   offset      every hunk's old lines are HEAD's lines at its stated start, and every new start is what git computes
+ *               (`git apply` would accept a hunk at a nearby offset, and a wrong `+c` it never reads)
+ *   apply       the section applies with no fuzz to HEAD, on a private index
+ *   post_image  the result's blob id is the `index` post-image id
+ *
+ * It never throws and never touches the real index or worktree. Exit modes of what it consumes (HC-GF-117):
+ *   stored == null              HANDLED: absent (the server has no review diff for that attempt).
+ *   head sha malformed          HANDLED: unverifiable/invalid_head.
+ *   head not in this clone      HANDLED: unverifiable/head_missing (`cat-file -e` exits 128).
+ *   HEAD moved since submit     HANDLED: unverifiable/head_moved — the diff describes another commit.
+ *   no sections                 HANDLED: unverifiable/no_sections — nothing was checked, so nothing matched.
+ *   git killed / timed out      HANDLED: unverifiable/timeout.  Deadline spent: unverifiable/deadline.
+ *   git spawn / other throw     HANDLED: unverifiable/git_error.
+ *   child killed by SIGINT      HANDLED: the temp dir is removed, then SIGINT is re-raised on this process. The git
+ *                               calls are synchronous, so no JS signal handler could run during them; the child's
+ *                               death is how an operator's Ctrl-C reaches this code.
+ */
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+const { gitEnv } = require('./git-env');
+
+const SHA_RE = /^[0-9a-f]{40}([0-9a-f]{24})?$/;
+const PER_CALL_MS = 15_000;
+const DEADLINE_MS = 60_000;
+const MAX_FILE_CHARS = 300;
+const TMP_PREFIX = 'hone-rdc-';
+// What a check can report. The server keeps only these (server/src/services/review-diff.js CHECK_STEPS/CHECK_REASONS,
+// pinned equal by a regression test). `fetch_failed` and `attempt_mismatch` are set by verify-patch in hone-cli.js.
+const STEPS = Object.freeze(['parse', 'pre_image', 'offset', 'apply', 'post_image']);
+const REASONS = Object.freeze(['ok', 'invalid_head', 'head_missing', 'head_moved', 'no_sections', 'timeout', 'git_error',
+  'fetch_failed', 'attempt_mismatch', 'deadline', 'context_mismatch', 'new_start_mismatch']);
+
+const INDEX_RE = /^index ([0-9a-f]{40}|[0-9a-f]{64})\.\.([0-9a-f]{40}|[0-9a-f]{64})(?: ([0-7]{6}))?$/;
+const HUNK_RE = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(?: .*)?$/;
+const NO_NEWLINE = '\';
+
+/** `diff --git a/<rel> b/<rel>` with the same <rel> twice, or null. A quoted path is not a plain path. */
+function relOfDiffGit(line) {
+  const PREFIX = 'diff --git a/';
+  if (!line.startsWith(PREFIX)) return null;
+  const rest = line.slice(PREFIX.length);
+  if ((rest.length - 3) % 2 !== 0 || rest.length < 5) return null;
+  const n = (rest.length - 3) / 2;
+  const a = rest.slice(0, n);
+  if (rest.slice(n, n + 3) !== ' b/' || rest.slice(n + 3) !== a || a.startsWith('"')) return null;
+  return a;
+}
+
+/**
+ * One section of `git diff --full-index` for a text modification. Every line must be accounted for: a mode, rename or
+ * copy header, a line beyond a hunk's counts, or a hunk out of order is a parse error, because `git apply` would read
+ * some of them and a reviewer would read all of them.
+ */
+function parseSection(text) {
+  const lines = text.split('\n');
+  if (lines.length && lines[lines.length - 1] === '') lines.pop();
+  const rel = relOfDiffGit(lines[0] || '');
+  const out = { rel, pre: null, post: null, mode: null, hunks: [], text, error: null };
+  const fail = (why) => ({ ...out, error: why });
+  if (rel === null) return fail('not a plain `diff --git a/<path> b/<path>` line');
+  const idx = INDEX_RE.exec(lines[1] || '');
+  if (!idx) return fail('line 2 is not a full-index `index` line');
+  out.pre = idx[1]; out.post = idx[2]; out.mode = idx[3] || null;
+  // git ends these two lines with a TAB when the path contains a space (diff.c, so a patch tool can find the name).
+  const tab = rel.includes(' ') ? '\t' : '';
+  if (lines[2] !== `--- a/${rel}${tab}`) return fail('line 3 is not `--- a/<path>`');
+  if (lines[3] !== `+++ b/${rel}${tab}`) return fail('line 4 is not `+++ b/<path>`');
+  let i = 4;
+  let prevEnd = 0;
+  while (i < lines.length) {
+    const h = HUNK_RE.exec(lines[i]);
+    if (!h) return fail(`line ${i + 1} is not a hunk header`);
+    const a = Number(h[1]); const b = h[2] === undefined ? 1 : Number(h[2]);
+    const c = Number(h[3]); const d = h[4] === undefined ? 1 : Number(h[4]);
+    if (b === 0 && d === 0) return fail(`line ${i + 1}: an empty hunk`);
+    const oldBegin = b === 0 ? a : a - 1;
+    if (oldBegin < 0 || oldBegin < prevEnd) return fail(`line ${i + 1}: hunks overlap or are out of order`);
+    prevEnd = oldBegin + b;
+    i += 1;
+    const oldLines = []; const newLines = [];
+    let ob = 0; let nd = 0;
+    while (ob < b || nd < d) {
+      const l = lines[i];
+      if (l === undefined) return fail('a hunk ends before its counts');
+      const k = l[0];
+      if (k === ' ') { oldLines.push(l.slice(1)); newLines.push(l.slice(1)); ob += 1; nd += 1; }
+      else if (k === '-') { oldLines.push(l.slice(1)); ob += 1; }
+      else if (k === '+') { newLines.push(l.slice(1)); nd += 1; }
+      else return fail(`line ${i + 1} is not a hunk line`);
+      if (ob > b || nd > d) return fail(`line ${i + 1} is beyond its hunk's counts`);
+      i += 1;
+      if (lines[i] === NO_NEWLINE) {
+        if (k !== '+') oldLines.noNewlineAt = oldLines.length - 1;
+        if (k !== '-') newLines.noNewlineAt = newLines.length - 1;
+        i += 1;
+      }
+    }
+    out.hunks.push({ a, b, c, d, oldBegin, oldLines, newLines });
+  }
+  if (!out.hunks.length) return fail('a section with no hunk');
+  return out;
+}
+
+/** Split a stored review diff on `diff --git`. Text before the first section is a section with an error. */
+function parseSections(text) {
+  const t = String(text || '');
+  if (!t.trim()) return [];
+  const starts = [];
+  for (const m of t.matchAll(/^diff --git /gm)) starts.push(m.index);
+  const sections = [];
+  const head = t.slice(0, starts.length ? starts[0] : t.length);
+  if (head.trim()) {
+    sections.push({ rel: null, pre: null, post: null, mode: null, hunks: [], text: head,
+      error: 'text outside a diff section' });
+  }
+  for (let i = 0; i < starts.length; i++) {
+    sections.push(parseSection(t.slice(starts[i], i + 1 < starts.length ? starts[i + 1] : t.length)));
+  }
+  return sections;
+}
+
+/** HEAD's lines, each with its own newline (the last may lack one). */
+function linesOf(blob) { return String(blob).match(/[^\n]*\n|[^\n]+$/g) || []; }
+
+/**
+ * The offsets git apply does not check. Old lines must be HEAD's lines at the stated start, byte for byte (newline
+ * included), and each new start must be what git computes from the old start and the hunks before it.
+ * @returns {null | 'context_mismatch' | 'new_start_mismatch'}
+ */
+function checkOffsets(section, blob) {
+  const head = linesOf(blob);
+  let delta = 0;
+  for (const h of section.hunks) {
+    if (h.oldBegin + h.b > head.length) return 'context_mismatch';
+    for (let j = 0; j < h.b; j++) {
+      const want = h.oldLines[j] + (h.oldLines.noNewlineAt === j ? '' : '\n');
+      if (head[h.oldBegin + j] !== want) return 'context_mismatch';
+    }
+    const expectC = h.a + delta + (h.b === 0 ? 1 : 0) - (h.d === 0 ? 1 : 0);
+    if (h.c !== expectC) return 'new_start_mismatch';
+    delta += h.d - h.b;
+  }
+  return null;
+}
+
+function defaultRunGit(repoRoot) {
+  return (args, { timeout, input, env } = {}) => execFileSync('git', args, {
+    cwd: repoRoot, env: gitEnv({ ...(env || {}), GIT_NO_LAZY_FETCH: '1' }), input,
+    encoding: 'utf8', maxBuffer: 64 * 1024 * 1024, timeout: Math.max(1, Math.floor(timeout || PER_CALL_MS)),
+    stdio: [input === undefined ? 'ignore' : 'pipe', 'pipe', 'pipe'],
+  });
+}
+
+class Stop extends Error {
+  constructor(result) { super(result.reason || result.status); this.result = result; }
+}
+
+/**
+ * @param {{stored: ({headSha: string, diff: string, notes?: string[]}|null), appliedHead: string, repoRoot: string,
+ *          runGit?: Function, now?: () => number, mkTemp?: () => string}} opts
+ * @returns {{status: 'match'|'mismatch'|'unverifiable'|'absent', headSha: (string|null), step: (string|null),
+ *            reason: (string|null), file: (string|null)}}
+ */
+function checkReviewDiff({ stored, appliedHead, repoRoot, runGit, now, mkTemp } = {}) {
+  const clock = now || Date.now;
+  const deadline = clock() + DEADLINE_MS;
+  let git = runGit || defaultRunGit(repoRoot || process.cwd());
+  const headSha = stored && typeof stored.headSha === 'string' && SHA_RE.test(stored.headSha) ? stored.headSha : null;
+  const result = (status, extra = {}) => ({ status, headSha, step: null, reason: null, file: null, ...extra });
+  const unverifiable = (reason) => result('unverifiable', { reason });
+  let tmp = null;
+  let interrupted = false;
+
+  // One git call, returning its stdout: a throw becomes a Stop (timeout, deadline, git_error, SIGINT) unless
+  // `allowExit` lets a non-zero exit through as `null` for the caller to judge.
+  const call = (args, { input, env, allowExit } = {}) => {
+    const left = Math.min(PER_CALL_MS, deadline - clock());
+    if (left <= 0) throw new Stop(unverifiable('deadline'));
+    try {
+      return String(git(args, { timeout: left, input, env }));
+    } catch (e) {
+      if (e && e.signal === 'SIGINT') { interrupted = true; throw new Stop(unverifiable('git_error')); }
+      if (e && (e.killed || e.code === 'ETIMEDOUT')) throw new Stop(unverifiable('timeout'));
+      if (allowExit && e && typeof e.status === 'number' && e.status !== 0) return null;
+      throw new Stop(unverifiable('git_error'));
+    }
+  };
+
+  try {
+    if (stored == null) return result('absent');
+    if (!headSha) return unverifiable('invalid_head');
+    // `git apply` skips a path outside the cwd's prefix and still exits 0, while `rev-parse :<rel>` resolves from the
+    // root: run from a subdirectory, a correct diff would read as a post_image mismatch. Every call uses the toplevel.
+    if (!runGit) git = defaultRunGit(call(['rev-parse', '--show-toplevel']).trim());
+    if (call(['cat-file', '-e', `${headSha}^{commit}`], { allowExit: true }) === null) return unverifiable('head_missing');
+    if (appliedHead !== headSha) return unverifiable('head_moved');
+    const sections = parseSections(stored.diff);
+    if (!sections.length) return unverifiable('no_sections');
+
+    tmp = (mkTemp || (() => fs.mkdtempSync(path.join(os.tmpdir(), TMP_PREFIX))))();
+    const indexEnv = { GIT_INDEX_FILE: path.join(tmp, 'index') };
+    call(['read-tree', headSha], { env: indexEnv });
+
+    for (const s of sections) {
+      const mismatch = (step, reason = null) => result('mismatch', { step, reason, file: s.rel });
+      if (s.error) return mismatch('parse');
+      const pre = call(['rev-parse', '--verify', '--quiet', `${headSha}:${s.rel}`], { allowExit: true });
+      if (pre === null || pre.trim() !== s.pre) return mismatch('pre_image');
+      const blob = call(['cat-file', 'blob', `${headSha}:${s.rel}`]);
+      const off = checkOffsets(s, blob);
+      if (off) return mismatch('offset', off);
+      const applied = call(['-c', 'apply.ignoreWhitespace=no', '-c', 'apply.whitespace=nowarn',
+        'apply', '--cached', '-'], { input: s.text, env: indexEnv, allowExit: true });
+      if (applied === null) return mismatch('apply');
+      const post = call(['rev-parse', '--verify', '--quiet', `:${s.rel}`], { env: indexEnv, allowExit: true });
+      if (post === null || post.trim() !== s.post) return mismatch('post_image');
+    }
+    return result('match', { reason: 'ok' });
+  } catch (e) {
+    return e instanceof Stop ? e.result : unverifiable('git_error');
+  } finally {
+    if (tmp) { try { fs.rmSync(tmp, { recursive: true, force: true }); } catch { /* best effort */ } }
+    if (interrupted) process.kill(process.pid, 'SIGINT');
+  }
+}
+
+/**
+ * Exactly what verify-patch posts as `reviewDiffCheck`: the six keys, `file` bounded. `attempt` is the step_4
+ * attempt whose stored diff was fetched and checked; the server binds the check to it.
+ */
+function toWireCheck(r, attempt) {
+  const c = r || {};
+  return {
+    status: c.status ?? null,
+    headSha: c.headSha ?? null,
+    attempt: Number.isInteger(attempt) ? attempt : null,
+    step: c.step ?? null,
+    reason: c.reason ?? null,
+    file: typeof c.file === 'string' ? c.file.slice(0, MAX_FILE_CHARS) : null,
+  };
+}
+
+module.exports = {
+  parseSections, checkReviewDiff, toWireCheck,
+  _internal: { parseSection, checkOffsets, linesOf, relOfDiffGit, SHA_RE, PER_CALL_MS, DEADLINE_MS, TMP_PREFIX, STEPS, REASONS },
+};

package/lib/review-diff.js

@@ -27,7 +27,7 @@ const crypto = require('node:crypto');
 const { execFileSync } = require('node:child_process');
 const { gitEnv } = require('./git-env');
 const { BUNDLE_MAX_PER_FILE_CHARS } = require('./bundle-limits');
-const { isSecretPath } = require('./bundle-context');
+const { pathRefusal } = require('./path-refusal');
 const { FILE_BLOCK_RE } = require('./block-grammar');
 
 const REVIEW_DIFF_MAX_CHARS = 60_000;      // diff text, summed over the files included
@@ -135,7 +135,7 @@ function computeReviewDiff({ repoRoot, rendered, runGit, now = Date.now, warn =
         // UTF-8 bytes >= UTF-16 length, so a size at or under the cap cannot be a length over it.
         const size = Number(String(git(['cat-file', '-s', `${headSha}:${rel}`], t)).trim());
         if (!Number.isFinite(size) || !overCap(size)) continue;
-        if (isSecretPath(rel)) { note(rel, 'secret path; not diffed'); continue; }
+        if (pathRefusal(rel, { mode: 'egress' })) { note(rel, 'secret path; not diffed'); continue; }
         t = left();
         if (t <= 0) { notes.push(`deadline reached; ${candidates.length - i} file(s) not diffed`); break; }
         const head = String(git(['cat-file', 'blob', `${headSha}:${rel}`], t));

package/lib/run-report.js

@@ -81,10 +81,13 @@ const CONSULT_REQUIRED_RE = new RegExp(`^${CONSULT_REQUIRED_CODE}:[^\\n]*`);
 /** The start of the message a batch run pauses with when its consult failed the mechanical check (orchestrator.js). */
 const CONSULT_NEEDS_PERSON_RE = /^architect consult needs a person to read it[^\n]*/;
 /**
- * The pause a consult whose OWN verdict is `checklist_b_completed: false` takes (workflow-dag.js FAILURE_ROUTING_TABLE.step_0b.step_0b_abort).
- * Approving it is refused (an `_abort` needs an acknowledgement, and even then nothing records a false verdict), so offering
- * `--approve` here is HC-GF-046 again: the line invites the one action the server has already decided to refuse.
- * tests/regression/HC-GF-030-run-report.test.js pins this prefix to the server's message.
+ * HC-GF-379-followup-1: the PAUSE-ERA message. Before HC-GF-379, a consult whose OWN verdict was `checklist_b_completed: false`
+ * paused the run with this message. Since HC-GF-379 a false consult routes back to step_0 (workflow-dag.js
+ * FAILURE_ROUTING_TABLE.step_0b.step_0b_abort: a retry, at most twice, then the run ends failed), so no new run pauses with it;
+ * this regex is kept only for runs that paused under the old routing. Approving one is refused (an `_abort` needs an
+ * acknowledgement, and even then nothing records a false verdict), so offering `--approve` here is HC-GF-046 again: the line
+ * invites the one action the server has already decided to refuse.
+ * tests/regression/HC-GF-030-run-report.test.js pins this branch verbatim with a literal pause-era message.
  */
 const CONSULT_ABORT_RE = /^step_0b: the architect consult did not complete Checklist B[^\n]*/;
 
@@ -101,6 +104,22 @@ const CONSULT_ABORT_RE = /^step_0b: the architect consult did not complete Check
  */
 const EXHAUSTED_RE = /^GARBAGE_OUTPUT at (step_[0-9a-z]+)/;
 
+/** HC-GF-036(b), HC-GF-379-followup-1: adverse verdicts in the agent's own vocabulary. Module scope so a test can pin
+ *  `step_0b_abort` to the kind failure-router.js's step_0b detector returns. */
+const ADVERSE_VERDICTS = Object.freeze({
+  review_reject: 'returned a FAIL review',
+  security_high: 'raised a HIGH security finding',
+  security_medium: 'raised a MEDIUM security finding',
+  test_fail: 'reported failing tests',
+  lint_fail: 'reported lint errors',
+  perf_finding: 'raised a performance finding',
+  validator_rejected: 'produced output the format validator rejected',
+  step_0b_abort: 'the architect consult answered false',
+});
+/** HC-GF-379: the run's error_message when the third false consult ends it (workflow-dag.js routeFailure's reason).
+ *  The packages cannot share it at runtime; tests/regression/HC-GF-030-run-report.test.js pins it to the producer. */
+const CONSULT_ROUTE_LIMIT_RE = /^max retries \((\d+)\) exceeded for step_0b:step_0b_abort$/;
+
 function buildReport(run, extra = {}) {
   const cfg = run.config || {};
   const steps = Array.isArray(run.steps) ? run.steps : [];
@@ -176,10 +195,23 @@ function buildReport(run, extra = {}) {
     }
   }
   if (run.status === 'failed') {
-    needsYou.push({
-      what: `run FAILED${run.errorMessage ? `: ${String(run.errorMessage).slice(0, 160)}` : ''}`,
-      how: `hone show step ${run.runId} ${run.currentStep || '<stepKey>'}`,
-    });
+    // HC-GF-379-followup-1: a third false consult ends the run failed at step_0b. Both the row AND the route's own
+    // reason must say so: a guardrail or budget that failed step_0b after one false verdict keeps the generic line.
+    const consultRow = steps.find((x) => x && x.stepKey === 'step_0b');
+    const limit = run.currentStep === 'step_0b'
+      && (consultRow && consultRow.diagnostics && consultRow.diagnostics.failure_record || {}).failure_kind === 'step_0b_abort'
+      && String(run.errorMessage || '').match(CONSULT_ROUTE_LIMIT_RE);
+    if (limit && ADVERSE_VERDICTS.step_0b_abort) {
+      needsYou.push({
+        what: `run FAILED: ${ADVERSE_VERDICTS.step_0b_abort} ${Number(limit[1]) + 1} times, the route-back limit`,
+        how: `hone show step ${run.runId} step_0b   (every consult attempt's findings, newest first)`,
+      });
+    } else {
+      needsYou.push({
+        what: `run FAILED${run.errorMessage ? `: ${String(run.errorMessage).slice(0, 160)}` : ''}`,
+        how: `hone show step ${run.runId} ${run.currentStep || '<stepKey>'}`,
+      });
+    }
   }
   // HC-GF-065: a KILLED run needs you too.
   //
@@ -226,17 +258,9 @@ function buildReport(run, extra = {}) {
     // conflation that was inflating batch failure_rates — and it points the operator at
     // the wrong thing to fix. The verdict kinds name the agent's own vocabulary.
     const kind = (s.diagnostics && s.diagnostics.failure_record || {}).failure_kind;
-    const VERDICT = {
-      review_reject: 'returned a FAIL review',
-      security_high: 'raised a HIGH security finding',
-      security_medium: 'raised a MEDIUM security finding',
-      test_fail: 'reported failing tests',
-      lint_fail: 'reported lint errors',
-      perf_finding: 'raised a performance finding',
-      validator_rejected: 'produced output the format validator rejected',
-    };
-    const what = kind && VERDICT[kind]
-      ? `${s.stepKey} (${s.agent || 'agent'}) ${VERDICT[kind]}`
+    if (kind === 'step_0b_abort') continue; // HC-GF-379-followup-1: reported once, in 1b′ below
+    const what = kind && ADVERSE_VERDICTS[kind]
+      ? `${s.stepKey} (${s.agent || 'agent'}) ${ADVERSE_VERDICTS[kind]}`
       : `${s.stepKey} (${s.agent || 'agent'}) ${s.status === 'failed' ? 'FAILED' : 'was REJECTED'}`;
     needsYou.push({
       what: `${what} — the run is recorded ${run.status}, so nothing downstream will revisit it`,
@@ -245,6 +269,35 @@ function buildReport(run, extra = {}) {
     });
   }
 
+  // 1b′. HC-GF-379-followup-1: the latest step_0b row is a false consult. Steps carry only the latest attempt, so a
+  // consult that went false and then true raises nothing here. Named once: skipped when the run-failed item or the
+  // pause-era abort branch above already names it.
+  {
+    const em = String(run.errorMessage || '');
+    const row = steps.find((x) => x && x.stepKey === 'step_0b');
+    const rowKind = row && (row.diagnostics && row.diagnostics.failure_record || {}).failure_kind;
+    const namedAbove = (run.status === 'failed' && run.currentStep === 'step_0b')
+      || (run.status === 'paused' && run.currentStep && em.match(CONSULT_ABORT_RE));
+    if (rowKind === 'step_0b_abort' && !namedAbove) {
+      // "Paused at step_0" means the plain gate only: the final else of the paused branch above.
+      const plainGate = run.status === 'paused' && run.currentStep === 'step_0' && !run.approvalRefusal
+        && ![BLOCKING_REASON_RE, EXHAUSTED_RE, CONSULT_REQUIRED_RE, CONSULT_NEEDS_PERSON_RE, CONSULT_ABORT_RE].some((re) => em.match(re));
+      const regrooming = run.status === 'running' || plainGate;
+      const suffix = regrooming
+        ? 'the run is re-grooming with these findings'
+        : `the run is recorded ${run.status}${run.status === 'failed' && run.currentStep ? ` at ${run.currentStep}` : ''}, `
+          + 'so nothing downstream will revisit it';
+      needsYou.push({
+        what: `step_0b: ${ADVERSE_VERDICTS.step_0b_abort} — ${suffix}`,
+        how: `hone show step ${run.runId} step_0b`,
+        howLabel: 'inspect',
+        // A run inside the consult loop needs nobody: the pipeline is answering the findings itself. Shown, not counted
+        // toward the exit code (a paused run's own gate item, when there is one, still is).
+        ...(regrooming ? { advisory: true } : {}),
+      });
+    }
+  }
+
   // 1c. HC-GF-041: a retry that came back with LESS than the attempt it replaces.
   //
   // The newest attempt REPLACES the previous one for every downstream consumer, so this
@@ -644,4 +697,6 @@ function renderReport(r) {
   return L.join('\n');
 }
 
-module.exports = { BLOCKING_REASON_CODES, buildReport, renderReport, durationOf, ACTIONABLE_GATE_VERDICTS };
+module.exports = {
+  BLOCKING_REASON_CODES, buildReport, renderReport, durationOf, ACTIONABLE_GATE_VERDICTS, ADVERSE_VERDICTS, CONSULT_ROUTE_LIMIT_RE,
+};