@hone-ai/cli 1.39.0 → 1.41.0

package/lib/run-context.js

@@ -25,7 +25,6 @@
  */
 
 const { composeStoryDescription } = require('./story-compose');
-const { extractStoryIdFromBranch } = require('./pipeline-status');
 const {
   extractPathRefs, extractBareRefs, resolveBareName, alreadyCovered, planFileExcerpt,
 } = require('./bundle-paths');
@@ -37,7 +36,6 @@ const { classifyStory } = require('./story-classifier');
 const {
   extractType, extractSecurityImplications, extractCrossRepoDependency,
 } = require('./story-classifier-extract');
-const { readArchitectConfigFromText } = require('./architect-config');
 const path = require('path');
 
 /**
@@ -49,13 +47,16 @@ const path = require('path');
  */
 const SERVER_OWNED_KEYS = Object.freeze([
   'batchTokenBudget', 'batchFailureThreshold', 'dependsOnRunIds', 'monthlyTokenBudget', 'overnight',
+  // HC-GF-030: whether a story was consulted is what the server's step_0b recorded, never what a
+  // client says. A client that could send these true would skip the consult.
+  'architect_consulted', 'checklist_b_completed', 'architect_consult',
 ]);
 
 // HC-019n-followup-13d: the bundle caps. OptionsFlow #96 hit 49,783 of the old 50,000 with six
 // files, so the next slightly larger story silently dropped one. 30 / 150K / 25K.
 const BUNDLE_MAX_FILES = 30;
 const BUNDLE_MAX_TOTAL_CHARS = 150_000;
-const BUNDLE_MAX_PER_FILE_CHARS = 25_000;
+const { BUNDLE_MAX_PER_FILE_CHARS } = require('./bundle-limits'); // HC-GF-390: shared with review-diff.js
 
 const info = (text) => ({ level: 'info', text });
 const warn = (text) => ({ level: 'warn', text });
@@ -158,7 +159,6 @@ async function issueStorySource(io, issueNumber, issue) {
  * @param {() => string} io.e2eSpecMode
  * @param {() => string} io.verificationGate
  * @param {() => string[]} io.verificationGateSources
- * @param {() => string} io.readPlanText                 EXECUTION_PLAN.yml text, '' when absent
  * @param {{ e2eSpecs?: boolean, skipE2eSpecs?: boolean, treeByteCap?: number }} [opts]  run-story's per-run
  *   flags; `treeByteCap` is queue-stories' byte cap on the tree's path lists (none for run-story)
  */
@@ -295,13 +295,7 @@ function resolveRepoContext(io, opts = {}) {
     config.verification_gate_sources = ['verify-patch'];
   }
 
-  // HC-019b: EXECUTION_PLAN.yml, read once. Each story's architect flags come from it below.
-  let planText = '';
-  try { planText = io.readPlanText() || ''; } catch (e) {
-    notes.push(warn(`  ⚠ EXECUTION_PLAN.yml read failed (non-fatal, architect flags default to {false, false}): ${firstLine(e)}`));
-  }
-
-  return { config, notes, repoFiles, defaultIncludePaths, planText, execution };
+  return { config, notes, repoFiles, defaultIncludePaths, execution };
 }
 
 /**
@@ -324,8 +318,8 @@ function resolveRepoContext(io, opts = {}) {
  * @param {object} repoCtx   resolveRepoContext's result
  * @param {string} storyId   the id as the operator typed it — sent as `storyId`
  * @param {{ explicitText?: string|null, explicitLabel?: string, explicitSource?: {kind: 'file'|'description', label?: string},
- *   includePaths?: string[], axes?: string }} [opts]
- * @returns {Promise<{ storyId: string, resolvedStoryId: string, rawText: string,
+ *   includePaths?: string[], axes?: string, consultArchitect?: boolean }} [opts]
+ * @returns {Promise<{ storyId: string, rawText: string,
  *   textSource: 'explicit'|'issue'|'roadmap'|null, textFailure: {kind:string, detail?:string}|null,
  *   config: object, bundle: {files:number, chars:number}, notes: {pre: object[], post: object[]} }>}
  */
@@ -336,7 +330,6 @@ async function resolveStoryContext(io, repoCtx, storyId, opts = {}) {
   let rawText = '';
   let textSource = null;
   let textFailure = null;
-  let resolvedStoryId = storyId; // canonical id for the architect-config lookup
 
   // ── Story text: explicit → GitHub issue → Hone roadmap ────────────────────────────────────
   // HC-GF-010: an EXPLICIT story source short-circuits both lookups, so the operator can never
@@ -369,17 +362,6 @@ async function resolveStoryContext(io, repoCtx, storyId, opts = {}) {
       const prov = await issueStorySource(io, storyId, issue);
       config.story_source = prov.source;
       pre.push(...prov.notes);
-      // HC-019b-followup-1 F1: the canonical story id from the issue title, or the architect
-      // lookup keys on '104' and silently misses every EXECUTION_PLAN.yml entry.
-      try {
-        const titleId = extractStoryIdFromBranch(issue.title);
-        if (titleId) {
-          resolvedStoryId = titleId;
-          pre.push(info(`  → resolved issue #${storyId} → canonical story id '${titleId}' for architect-config lookup`));
-        } else {
-          pre.push(warn(`  ⚠ could not extract canonical story id from issue title '${issue.title}' — architect-config lookup will use '${storyId}' (likely silent miss)`));
-        }
-      } catch { /* extractor throws → fall back to the numeric id */ }
     } catch (e) {
       textFailure = { kind: 'issue-error', detail: firstLine(e) };
       // HC-GF-270: stated rather than left absent, so the later pause is readable. Classified, not
@@ -392,7 +374,6 @@ async function resolveStoryContext(io, repoCtx, storyId, opts = {}) {
       };
       pre.push(warn(`  ⚠ could not fetch GitHub issue context: ${firstLine(e)}`));
       pre.push(warn('  → proceeding without story_description; step_0 may produce placeholder output'));
-      pre.push(warn(`  ⚠ architect-config lookup will use '${storyId}' (likely silent miss)`));
     }
   } else {
     // HC-019n-followup-18: a roadmap-sourced story. Only the SERVER knows what it says; only the
@@ -540,11 +521,14 @@ async function resolveStoryContext(io, repoCtx, storyId, opts = {}) {
           path: candidate,
         });
         content = excerpt.content;
-        if (excerpt.notice) pre.push(warn(excerpt.notice));
-        for (const w of anchorWarnings(anchors, excerpt.unhonoured)) pre.push(warn(w));
         if (totalChars + content.length > BUNDLE_MAX_TOTAL_CHARS) { budgetSpent = true; break; }
         totalChars += content.length;
         codebaseFiles.push({ path: candidate, content });
+        // Only a file that made the bundle gets the "bundled lines A-B" notice: announced before the
+        // budget check, a dropped file printed it AND the NOT-bundled line below, and the operator
+        // read the first one (seen 2026-10-16 on server/scripts/seed-agent-prompts.js).
+        if (excerpt.notice) pre.push(warn(excerpt.notice));
+        for (const w of anchorWarnings(anchors, excerpt.unhonoured)) pre.push(warn(w));
       }
       // HC-GF-288: an operator-named entry whose file never reached the bundle (the budget ran
       // out first, or it names a directory) vanished as silently as the anchor did. A refused
@@ -597,6 +581,11 @@ async function resolveStoryContext(io, repoCtx, storyId, opts = {}) {
     }
   }
 
+  // ── Architect consult on request (HC-GF-397) ─────────────────────────────────────────────
+  // --consult-architect: the server runs step_0b even on a `not_engaged` grooming. Sent only as `true`; the server reads
+  // nothing else as a request, and no value of it can skip a consult.
+  if (opts.consultArchitect === true) config.consult_architect = true;
+
   // ── Classifier axes (HC-COMM-010) ─────────────────────────────────────────────────────────
   // Explicit --axes wins. Otherwise the DETERMINISTIC axes from the extractors; judgment axes
   // come from the groomer at step_0 and are harvested server-side. Fail-open.
@@ -621,19 +610,7 @@ async function resolveStoryContext(io, repoCtx, storyId, opts = {}) {
     }
   }
 
-  // ── Architect flags (HC-019b) ─────────────────────────────────────────────────────────────
-  // workflow-dag.js's validateStepPreConditions BLOCKS step_1 when architect_consulted is true
-  // and checklist_b_completed is not; without these flags every architect-engaged story
-  // deadlocks. Keyed on the RESOLVED id (HC-019b-followup-1 F1).
-  const arch = readArchitectConfigFromText(repoCtx.planText || '', resolvedStoryId);
-  config.architect_consulted = arch.architect_consulted;
-  config.checklist_b_completed = arch.checklist_b_completed;
-  if (arch.diagnostic) post.push(warn(`  ⚠ ${arch.diagnostic}`));
-  if (arch.architect_consulted) {
-    post.push(info(`  → architect_consulted: true, checklist_b_completed: ${arch.checklist_b_completed}`));
-  }
-
-  return { storyId, resolvedStoryId, rawText, textSource, textFailure, config, bundle, notes: { pre, post } };
+  return { storyId, rawText, textSource, textFailure, config, bundle, notes: { pre, post } };
 }
 
 /**

package/lib/run-report.js

@@ -18,7 +18,7 @@
 
 // HC-GF-234: the one wording for a step's unanswered question, shared with `--status`, `show
 // step` and the human-gate prompt. A pure leaf module, so this file stays pure.
-const { normalizeQuestion, questionLines, countPhrase } = require('./operator-question');
+const { normalizeQuestion, questionLines, countPhrase, scrub } = require('./operator-question');
 
 /** Gate verdicts the pipeline already speaks. Do not invent synonyms. */
 const ACTIONABLE_GATE_VERDICTS = ['fail', 'unavailable'];
@@ -69,6 +69,25 @@ function durationOf(startedAt, endedAt) {
 const BLOCKING_REASON_CODES = Object.freeze(['MAX_RETRIES_EXCEEDED', 'MAX_TOTAL_STEPS_EXCEEDED']);
 const BLOCKING_REASON_RE = new RegExp(`^(${BLOCKING_REASON_CODES.join('|')})[^\\n]*`);
 
+/**
+ * HC-GF-030: the pause the architect-consult guard takes. NOT in BLOCKING_REASON_CODES, which is pinned equal to
+ * what orchestrator-guardrails.js emits (HC-GF-046b); this one is emitted by workflow-dag.js's
+ * validateStepPreConditions. Approving is refused for it too — by the route and by approveGate — so it is a decision
+ * and not a gate. The server package and this one cannot share a constant, so
+ * tests/regression/HC-GF-030-run-report.test.js pins this string equal to architect-consult.js CONSULT_REQUIRED_CODE.
+ */
+const CONSULT_REQUIRED_CODE = 'ARCHITECT_CONSULT_REQUIRED';
+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.
+ */
+const CONSULT_ABORT_RE = /^step_0b: the architect consult did not complete Checklist B[^\n]*/;
+
 /**
  * HC-GF-046(b), corrected in review: a step that used up its format retries.
  *
@@ -107,7 +126,28 @@ function buildReport(run, extra = {}) {
     // untrustworthy in the other direction.
     const blocked = String(run.errorMessage || '').match(BLOCKING_REASON_RE);
     const exhausted = String(run.errorMessage || '').match(EXHAUSTED_RE);
-    if (run.approvalRefusal) {
+    const consultRequired = String(run.errorMessage || '').match(CONSULT_REQUIRED_RE);
+    const consultNeedsPerson = String(run.errorMessage || '').match(CONSULT_NEEDS_PERSON_RE);
+    const consultAbort = String(run.errorMessage || '').match(CONSULT_ABORT_RE);
+    if (consultRequired) {
+      needsYou.push({
+        what: `run CANNOT proceed at ${run.currentStep} — ${scrub(consultRequired[0].slice(0, 400))}. There is no waiver and `
+          + 'approving is refused, so this is a decision, not a gate',
+        how: `hone run-story ${run.runId} --kill   (then re-run the story: step_0 is cached, so it costs one consult)`,
+      });
+    } else if (consultNeedsPerson) {
+      needsYou.push({
+        what: `the architect consult is waiting for a person to read it — ${scrub(consultNeedsPerson[0].slice(0, 400))}`,
+        how: `hone show step ${run.runId} step_0b   (then hone run-story ${run.runId} --approve step_0b once you have read it)`,
+      });
+    } else if (consultAbort) {
+      needsYou.push({
+        what: `the architect consult did not pass at ${run.currentStep} — ${scrub(consultAbort[0].slice(0, 400))}. Approving is refused, `
+          + 'so this is a decision, not a gate',
+        how: `hone show step ${run.runId} step_0b   (read what it flagged, change the story to answer it, `
+          + `then hone run-story ${run.runId} --kill and run the story again)`,
+      });
+    } else if (run.approvalRefusal) {
       // HC-GF-074: rendered from the server's own decision, never re-derived from verdict records here.
       needsYou.push({
         what: `run CANNOT be approved at ${run.currentStep} as it stands — ${String(run.approvalRefusal.message).slice(0, 300)}`,
@@ -430,6 +470,26 @@ function buildReport(run, extra = {}) {
       worthKnowing.push(`${s.stepKey} ran ${s.attempts} times`);
     }
   }
+  // HC-GF-030: a run that finished with an architect classified as needed and no consult recorded. The consult
+  // guard makes this unreachable for a run the server drove; it is said here because "no run records
+  // `architect_engaged: true` with no consult" is the acceptance, and a report is where that gets checked.
+  const arch = run.architect && typeof run.architect === 'object' ? run.architect : null;
+  // HC-GF-397-followup-1: `hone run-story --consult-architect` asks for a consult on a `not_engaged` grooming. Read the way
+  // the server reads it — the boolean `true` only — so a requested consult that is not approved is never "not needed".
+  const consultRequested = cfg.consult_architect === true;
+  if (arch && (arch.verdict !== 'not_engaged' || consultRequested) && !arch.consulted && run.status === 'completed') {
+    const why = arch.verdict === 'engaged' ? 'the architect classified as needed'
+      : arch.verdict === 'not_engaged' ? 'an architect consult REQUESTED with --consult-architect'
+      : 'the architect verdict unreadable';
+    needsYou.push({
+      what: `run COMPLETED with ${why} and NO approved consult`,
+      how: `hone show step ${run.runId} step_0b`,
+      // HC-026c: a new signal must not turn every run that finished BEFORE the consult step existed into a failing exit
+      // code (about 27 of 28 completed runs on the local server were engaged). Shown in full, counted in `needsYou`, and
+      // not gating: the consult guard is what stops a new run, and this line is for reading a run that predates it.
+      advisory: true,
+    });
+  }
   // The two "blind run" tells, both from HC-GF-006's preflight reasoning.
   const descChars = typeof cfg.story_description === 'string' ? cfg.story_description.length : 0;
   if (descChars === 0) {
@@ -459,9 +519,21 @@ function buildReport(run, extra = {}) {
     duration: durationOf(run.startedAt, run.completedAt),
     cost: extra.cost || null,
     architectConsulted: cfg.architect_consulted === true,
+    // HC-GF-030: derived server-side from the step rows, never from config. null on a server that predates it.
+    architect: arch ? {
+      verdict: arch.verdict, consulted: arch.consulted === true, requested: consultRequested,
+      // A number or nothing: this is printed, and it came off the network.
+      consultAttempt: Number.isFinite(Number(arch.consultAttempt)) && Number(arch.consultAttempt) > 0 ? Math.trunc(Number(arch.consultAttempt)) : null,
+      blockers: Number(arch.blockers) || 0,
+      // Agent-written text going to a terminal: the server scrubs it, and this CLI may be talking to an older or different
+      // server, so it scrubs again where it is stored for printing (the rule cli/lib/operator-question.js already keeps).
+      findings: (Array.isArray(arch.findings) ? arch.findings : []).map(f => scrub(String(f).slice(0, 400))),
+      callSiteGaps: (Array.isArray(arch.callSiteGaps) ? arch.callSiteGaps : []).map(g => scrub(String(g).slice(0, 400))),
+    } : null,
     storyDescriptionChars: descChars,
     bundledFiles: bundled,
-    classifierAxes: Array.isArray(cfg.classifier_axes) ? cfg.classifier_axes : [],
+    // The groomer's own words (the server harvests them from step_0's output), printed on a terminal: scrubbed, and strings only.
+    classifierAxes: Array.isArray(cfg.classifier_axes) ? cfg.classifier_axes.map(a => scrub(String(a).slice(0, 80))) : [],
     needsYou,
     worthKnowing,
     steps,
@@ -530,6 +602,21 @@ function renderReport(r) {
     L.push('');
   }
 
+  if (r.architect) {
+    const a = r.architect;
+    L.push('ARCHITECT');
+    L.push(`  ${a.verdict === 'engaged' ? 'engaged' : a.verdict === 'not_engaged' ? 'not engaged (step_0 said so, readably)' : 'verdict unreadable (the consult runs)'}`
+      + `${r.classifierAxes.length ? ` · axes: ${r.classifierAxes.join(', ')}` : ''}`
+      // HC-GF-397-followup-1: the request is named only where it changed the outcome — an engaged or unreadable verdict
+      // runs the consult anyway, so its line stays as it was.
+      + `${a.requested && a.verdict === 'not_engaged' ? ' · consult requested (--consult-architect)' : ''}`
+      + ` · consult ${a.consulted ? `approved${a.consultAttempt ? ` (step_0b attempt ${a.consultAttempt})` : ''}` : a.verdict === 'not_engaged' && !a.requested ? 'not needed' : 'NOT approved'}`);
+    if (a.blockers > 0) L.push(`  ${a.blockers} finding(s) marked BLOCKER`);
+    for (const f of a.findings) L.push(`  · ${f}`);
+    for (const g of a.callSiteGaps) L.push(`  ⚠ call sites the consult could not see: ${g}`);
+    L.push('');
+  }
+
   L.push('STEPS');
   for (const s of r.steps) {
     const mark = s.status === 'completed' ? '✓' : s.status === 'skipped' ? '○' : '·';
@@ -540,8 +627,11 @@ function renderReport(r) {
   L.push('');
 
   L.push('RUN FACTS');
+  // HC-GF-030: the consult state comes from the server's step rows when it reports them (`architect`); the config flag is
+  // only a mirror, cleared by a new grooming, and is what an older server still reports.
+  const consultedFact = r.architect ? r.architect.consulted : r.architectConsulted;
   L.push(`  mode ${r.mode || 'unknown'} · story text ${r.storyDescriptionChars} chars · `
-         + `${r.bundledFiles} file(s) bundled · architect_consulted ${r.architectConsulted}`);
+         + `${r.bundledFiles} file(s) bundled · architect_consulted ${consultedFact}`);
   if (r.classifierAxes.length) L.push(`  axes: ${r.classifierAxes.join(', ')}`);
   if (r.verifications.length) {
     for (const v of r.verifications) {

package/lib/security-scanner.js

@@ -14,13 +14,15 @@
 const SECRET_PATTERNS = [
   {
     id: 'hardcoded-secret-apikey',
-    pattern: /(?:api[_-]?key|apikey|api[_-]?secret)\s*[:=]\s*["']([A-Za-z0-9/+=]{20,})["']/i,
+    // HC-GF-364: `["']?` after the name reads a quoted key — JSON, a dict literal — as the served
+    // workflow's scan does since HC-GF-362.
+    pattern: /(?:api[_-]?key|apikey|api[_-]?secret)["']?\s*[:=]\s*["']([A-Za-z0-9/+=]{20,})["']/i,
     severity: 'HIGH',
     message: 'Hardcoded API key detected. Use environment variables instead.',
   },
   {
     id: 'hardcoded-secret-password',
-    pattern: /(?:password|passwd|pwd|secret|token)\s*[:=]\s*["']([A-Za-z0-9@#$%^&*!]{16,})["']/i,
+    pattern: /(?:password|passwd|pwd|secret|token)["']?\s*[:=]\s*["']([A-Za-z0-9@#$%^&*!]{16,})["']/i,
     severity: 'HIGH',
     message: 'Hardcoded password/secret detected. Use environment variables or a vault.',
   },
@@ -126,8 +128,9 @@ function scanFiles(opts = {}) {
 
       // Skip env var references (not hardcoded)
       if (/process\.env\.|os\.environ|System\.getenv|ENV\[/i.test(line)) continue;
-      // Skip comments
-      if (/^\s*(\/\/|#|--|\/\*|\*)/.test(line)) continue;
+      // Skip comments. `--` is a SQL comment; `-----BEGIN … PRIVATE KEY-----` is not (HC-GF-362: it was
+      // skipped as one, so the private-key rule never fired on a key at the start of a line).
+      if (/^\s*(\/\/|#|--(?!-)|\/\*|\*)/.test(line)) continue;
 
       for (const rule of rules) {
         if (rule.pattern.test(line)) {

package/lib/tree-artifact.js

@@ -18,14 +18,34 @@
  *   malformed[] unparsable block    — DELIBERATELY NOT REACHABLE: every fence we emit is longer
  *                                     than any fence run inside the file it wraps (see below).
  *   noChanges   the honest no-op    — HANDLED: a clean tree says NO CHANGES rather than nothing.
+ *                                     HC-GF-395: it says "matches HEAD" only when git reported no
+ *                                     change at all (`!changed.length`). When git reported changes
+ *                                     but none could be sent (`!included.length`), it says "NO
+ *                                     CHANGES — the working tree differs from HEAD, but no changed
+ *                                     file could be sent as content (N skipped; see ### Not
+ *                                     included)", N counting named skips only (symlinks are silent).
  *
- * Dependency-free by intent, like `cli/lib/headroom.js`: `git`, `fs` and `path` only.
+ * Dependency-free by intent, like `cli/lib/headroom.js`: `git`, `fs` and `path`, plus the one
+ * classifier the bundler already uses — `isSecretPath` from `./bundle-context`, which itself
+ * requires only `path`.
+ *
+ * HC-GF-393: a path `isSecretPath()` classifies (`.env*`, `*.pem`, `id_rsa`-style keys, …) is
+ * never read. It is named under `### Not included`, so it is absent from the patch and the PR
+ * on purpose and visibly, not silently. A deleted one still renders as `DELETE:` (no content).
+ *
+ * HC-GF-394: a file that cannot be read is named under `### Not included` as `unreadable`. It used
+ * to throw, and the whole submission failed with it — every readable change included.
+ *
+ * HC-GF-390: for step_4 the submit also computes a review-only base diff of the over-cap files this
+ * render emitted whole (`cli/lib/review-diff.js`). It is sent as a separate `reviewDiff` field and
+ * stored apart; it is never part of this artifact, and nothing here changes because of it.
  */
 
 const fs = require('node:fs');
 const path = require('node:path');
 const { execFileSync } = require('node:child_process');
 const { gitEnv } = require('./git-env');
+const { isSecretPath } = require('./bundle-context');
 
 /** Bytes above which we do not attempt to inline a file at all. */
 const MAX_FILE_BYTES = 1_000_000;
@@ -119,6 +139,9 @@ function renderFromTree({ repoRoot, testReport } = {}) {
   const skipped = [];
 
   for (const rel of changed) {
+    // First, before lstat or read: the bytes of a secret path never enter this process. The name
+    // is the signal, so a symlink or an oversized file with a secret name is listed as a secret.
+    if (isSecretPath(rel)) { skipped.push({ path: rel, reason: 'secret path — not sent' }); continue; }
     const abs = path.join(repoRoot, rel);
     let st;
     try { st = fs.lstatSync(abs); } catch { skipped.push({ path: rel, reason: 'unreadable' }); continue; }
@@ -129,7 +152,8 @@ function renderFromTree({ repoRoot, testReport } = {}) {
     if (st.isSymbolicLink() || !st.isFile()) continue;
     if (st.size > MAX_FILE_BYTES) { skipped.push({ path: rel, reason: `larger than ${MAX_FILE_BYTES} bytes` }); continue; }
 
-    const buf = fs.readFileSync(abs);
+    let buf;
+    try { buf = fs.readFileSync(abs); } catch { skipped.push({ path: rel, reason: 'unreadable' }); continue; }
     if (looksBinary(buf)) { skipped.push({ path: rel, reason: 'binary' }); continue; }
 
     const content = buf.toString('utf8');
@@ -141,9 +165,18 @@ function renderFromTree({ repoRoot, testReport } = {}) {
 
   const lines = ['## Changed Files', ''];
 
-  if (!included.length && !deleted.length) {
+  if (!changed.length && !deleted.length) {
     // The honest no-op, in the shape the validator and the materialiser both already accept.
     lines.push('NO CHANGES — the working tree matches HEAD.');
+  } else if (!included.length && !deleted.length) {
+    // HC-GF-395: still a no-op, but not a clean tree. One line with the same `NO CHANGES —` prefix,
+    // which every parser keys on; the rest of the line is the reason stored in the artifact (the
+    // CLI's own no-op messages are fixed text). Only a
+    // named skip has a list to point at; a symlink or non-regular file is skipped silently.
+    const why = skipped.length
+      ? `${skipped.length} skipped; see ### Not included`
+      : 'symlinks and non-regular files are not sent';
+    lines.push(`NO CHANGES — the working tree differs from HEAD, but no changed file could be sent as content (${why}).`);
   } else {
     for (const b of blocks) { lines.push(b, ''); }
     for (const rel of deleted) lines.push(`DELETE: ${rel}`);

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.39.0",
+  "version": "1.41.0",
   "description": "Hone AI — Enterprise SDLC Pipeline CLI",
   "main": "hone-cli.js",
   "bin": {