@hone-ai/cli 1.38.1 → 1.40.0

package/lib/verify-patch.js

@@ -262,23 +262,97 @@ function verdictFromRun(run, provisioning = null) {
       missing: absent.missing,
     };
   }
-  const sum = summarizeFailure(run);
+  const sum = summarizeFailure(run, { runner: true });
   // HC-GF-023: lead with HOW MANY. "1 of 8 named" and "the only failure" are
   // different situations that this line used to render identically.
-  const head = `tests failed (exit ${run.code})`
-    + (sum.count > 1 ? ` — ${sum.count} failure lines` : '');
-  return {
-    verdict: 'fail',
-    exitCode: EXIT.TESTS_FAILED,
-    detail: head + (sum.first ? `, first: ${sum.first}` : ''),
-    failure: sum,
-  };
+  // HC-GF-363: and with WHICH, from the runner's own failure records. This detail is the only verification
+  // text a retried builder receives, so it names the failing tests, not lines that merely contain "Error".
+  // The wording never writes "<n> tests failed/failing": the failure router reads that as a test failure
+  // (FAIL_COUNT_RE in server/src/services/failure-router.js) and a builder that echoed it would be re-routed.
+  const head = `tests failed (exit ${run.code})`;
+  const first = sum.first ? `, first: ${routerSafe(sum.first)}` : '';
+  let detail;
+  if (sum.source === 'runner') {
+    const named = sum.tests.map((t) => routerSafe(t.slice(0, 160))).join('; ');
+    const more = sum.count > sum.tests.length ? `; +${sum.count - sum.tests.length} more` : '';
+    detail = `${head} — ${sum.count} failing ${sum.count === 1 ? 'test' : 'tests'} (runner records): ${named}${more}${first}`;
+  } else {
+    detail = head + (sum.count > 1 ? ` — ${sum.count} failure lines (pattern match, no runner records)` : '') + first;
+  }
+  return { verdict: 'fail', exitCode: EXIT.TESTS_FAILED, detail, failure: sum };
 }
 
 /** Lines that look like a runner reporting a failure. Deliberately broad — this
  *  counts EVIDENCE of failure across pytest/node/jest/go/cargo, not test cases. */
 const FAILURE_LINE_RE = /(^|[\s│|])(FAILED|FAIL|ERROR|ERR!|not ok|✗|✖|×)\b|\w+Error\b|panic:|AssertionError/;
 
+/**
+ * HC-GF-363 (review MED-1): adopter text (a test's name, a log line) rides inside the detail, and the detail can be
+ * echoed into step_4's output, which the server's failure router READS. A failing test named `reports 2 tests failed`
+ * would route as `test_fail`, and a linter line `3 errors, 0 warnings` as `lint_fail`. This quotes the phrases the
+ * router's step_4 and step_5 detectors match (a count before "tests failed/failing" or "errors", "lint failed",
+ * "eslint error:", the `[UNKNOWN … operator must supply]` blocker, a `REVIEW SUMMARY:` verdict) so none can match;
+ * the words stay readable. Idempotent. tests/regression/HC-GF-363-auto-reject.test.js runs the REAL detectFailure.
+ */
+function routerSafe(text) {
+  return String(text == null ? '' : text)
+    .replace(/(\d+)(\s+)(tests?)(\s+)(failing|failed)\b/gi, '$1$2"$3"$4$5')
+    .replace(/(\d+)(\s+)(errors?)\b/gi, '$1$2"$3"')
+    .replace(/\b(lint(?:ing)?)(\s+)(failed)\b/gi, '$1$2"$3"')
+    .replace(/\b(eslint|ruff|mypy)(\s+)(error)(\s*:)/gi, '$1$2"$3"$4')
+    .replace(/\[UNKNOWN\b/gi, '[ UNKNOWN')
+    .replace(/REVIEW(\s+)SUMMARY:/gi, 'REVIEW$1"SUMMARY":')
+    .replace(/##(\s+)Abort(\s+)Reason:/gi, '# #$1Abort$2Reason:');
+}
+
+/**
+ * HC-GF-363 — the failure records a test RUNNER prints, anchored at the start of the line. A line that merely
+ * contains "Error" or "FAIL" in a test's name (`✔ parseGhError recognizes …`, `ok 7 - … FAIL …`) is a PASS record
+ * and matches none of these: on the pilot's log 118 of the 124 lines FAILURE_LINE_RE flagged were passes.
+ * Each returns the failing test's name, or null when the line is not that runner's failure record.
+ */
+const RUNNER_RECORDS = Object.freeze([
+  // TAP (node --test, tap, prove): `not ok 3 - name`. A `# TODO` / `# SKIP` directive is not a failure.
+  ['tap', (l) => {
+    const m = l.match(/^\s*not ok\b(.*)$/);
+    if (!m || /#\s*(?:TODO|SKIP)\b/i.test(m[1])) return null;
+    return m[1].replace(/^\s*\d*\s*(?:-\s*)?/, '').trim() || 'not ok';
+  }],
+  // node:test spec reporter: `✖ name (12ms)` (U+2716), also printed again in its `✖ failing tests:` recap. eslint's
+  // own `✖ 3 problems` summary is not a test.
+  ['spec', (l) => {
+    const m = l.match(/^\s*\u2716\s+(.*)$/);
+    if (!m || /^failing tests\b/i.test(m[1]) || /^\d+\s+problems?\b/i.test(m[1]) || /#\s*(?:TODO|SKIP)\b/i.test(m[1])) return null;
+    return m[1].replace(/\s*\(\d+(?:\.\d+)?\s*ms\)\s*$/, '').trim() || null;
+  }],
+  // jest: `✕ name (3 ms)` (U+2715)
+  ['jest', (l) => {
+    const m = l.match(/^\s*\u2715\s+(.*)$/);
+    return m ? (m[1].replace(/\s*\(\d+(?:\.\d+)?\s*ms\)\s*$/, '').trim() || null) : null;
+  }],
+  // pytest: the short summary `FAILED path::test - reason` / `ERROR path::test`, and verbose `path::test FAILED`
+  ['pytest', (l) => {
+    const m = l.match(/^(?:FAILED|ERROR)\s+(\S+\.py::\S*)/) || l.match(/^(\S+\.py::\S+)\s+FAILED\b/);
+    return m ? m[1] : null;
+  }],
+  // go test: `--- FAIL: TestX (0.00s)` (subtests are indented)
+  ['go', (l) => { const m = l.match(/^\s*--- FAIL:\s+(\S+)/); return m ? m[1] : null; }],
+  // cargo test: `test path::name ... FAILED`
+  ['cargo', (l) => { const m = l.match(/^test\s+(\S+)\s+\.\.\.\s+FAILED$/); return m ? m[1] : null; }],
+]);
+
+/** The failing test a runner record names, or null. Pure. */
+function runnerFailure(line) {
+  for (const [, read] of RUNNER_RECORDS) {
+    const name = read(line);
+    if (name) return name;
+  }
+  return null;
+}
+
+/** A line the runner prints for a test that did NOT fail (or an announcement, or a TODO/SKIP): never "the first failure". */
+const RUNNER_NON_FAILURE_RE = /^\s*(?:ok\b|not ok\b[^\n]*#\s*(?:TODO|SKIP)\b|#\s*Subtest:|[\u2714\u2713]\s|--- (?:PASS|SKIP):|=== (?:RUN|PAUSE|CONT)\b|test \S+ \.\.\. ok$|\S+::\S+\s+PASSED\b|PASSED\s)/;
+
 /**
  * HC-GF-023 — summarise a failed run instead of quoting one line of it.
  *
@@ -290,19 +364,52 @@ const FAILURE_LINE_RE = /(^|[\s│|])(FAILED|FAIL|ERROR|ERR!|not ok|✗|✖|×)\
  * re-run. A one-line quote of a multi-failure run is not a summary; it is a
  * sample presented as a conclusion.
  *
+ * HC-GF-363: `runner: true` (verdictFromRun only) counts and names the runner's own failure records first
+ * (RUNNER_RECORDS) and says which it used. `first` is then the first broad-pattern line that is not a runner PASS
+ * record, so a SyntaxError still leads the FAILED names (HC-GF-023) and a passing test never does. With no runner
+ * record, or without the option (classifyGateRun: a linter prints `✖ N problems`, which is not a test), it is the
+ * broad pattern exactly as before.
+ *
  * Pure: returns the count, the FIRST failure (usually nearer the cause than the
  * last) and a tail excerpt. Writing the full log is IO and stays in the CLI.
  *
- * @returns {{ count: number, first: string, excerpt: string[] }}
+ * @returns {{ count: number, first: string, excerpt: string[], tests: string[], source: 'runner'|'pattern' }}
+ *   `tests`: up to 10 failing test names (200 chars each) from runner records, in order, repeats removed;
+ *   `count`: the number of distinct runner records (source 'runner') or of broad-pattern lines ('pattern')
  */
-function summarizeFailure({ stdout = '', stderr = '' }, { maxLines = 12 } = {}) {
+function summarizeFailure({ stdout = '', stderr = '' }, { maxLines = 12, runner = false } = {}) {
   const lines = `${stdout}\n${stderr}`.split('\n').map(l => l.replace(/\s+$/, ''));
   const nonEmpty = lines.filter(l => l.trim());
+  const excerpt = nonEmpty.slice(-maxLines).map(l => l.slice(0, 300));
   const failing = nonEmpty.filter(l => FAILURE_LINE_RE.test(l));
+  if (runner) {
+    const names = [];
+    let firstRecord = '';
+    for (const l of nonEmpty) {
+      const n = runnerFailure(l);
+      if (!n) continue;
+      if (!firstRecord) firstRecord = l;
+      if (!names.includes(n)) names.push(n);
+    }
+    if (names.length) {
+      // TAP prints a test's own stdout as `# …` comment lines, so a passing test that logs a TypeError must not lead.
+      const tap = nonEmpty.some(l => /^\s*not ok\b/.test(l));
+      const lead = failing.find(l => !RUNNER_NON_FAILURE_RE.test(l) && !(tap && /^\s*#\s/.test(l))) || firstRecord;
+      return {
+        count: names.length,
+        first: lead.trim().slice(0, 200),
+        excerpt,
+        tests: names.slice(0, 10).map(n => n.slice(0, 200)),
+        source: 'runner',
+      };
+    }
+  }
   return {
     count: failing.length,
     first: (failing[0] || nonEmpty[nonEmpty.length - 1] || '').trim().slice(0, 200),
-    excerpt: nonEmpty.slice(-maxLines).map(l => l.slice(0, 300)),
+    excerpt,
+    tests: [],
+    source: 'pattern',
   };
 }
 
@@ -419,6 +526,8 @@ function classifyGateRun(run) {
     return { verdict: 'unavailable', detail: 'output exceeded the capture buffer (ENOBUFS) — gate NOT run to completion' };
   }
   if (run.code === 0) return { verdict: 'pass', detail: 'clean' };
+  // HC-GF-363: no `runner` option, on purpose. A linter's `✖ N problems` is not a test record, and this detail is
+  // pinned byte for byte by the first-finding ordering below.
   const sum = summarizeFailure(run, { maxLines: 6 });
   // A linter prints its findings from the TOP, so unlike a test runner the most
   // useful line is the first, not the last. summarizeFailure's fallback is the
@@ -438,4 +547,5 @@ module.exports = {
   EXIT, resolveCommand, resolveCommandDetailed, DEFAULT_COMMAND,
   AUX_GATES, AUX_DETECT, resolveAuxGates, classifyGateRun,
   verdictFromRun, commandAbsence, verifyCommandEnv, lastMeaningfulLine, summarizeFailure, FAILURE_LINE_RE,
+  RUNNER_RECORDS, runnerFailure, routerSafe,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hone-ai/cli",
-  "version": "1.38.1",
+  "version": "1.40.0",
   "description": "Hone AI — Enterprise SDLC Pipeline CLI",
   "main": "hone-cli.js",
   "bin": {