rcf-lite 0.19.0 → 0.20.0

package/src/verify/chain/index.js

@@ -142,6 +142,63 @@ function boundTcsFor(testSuites, acId) {
   return out;
 }
 
+/**
+ * rcf-eval-node spec 2026-09-04 sections 3 + 5. Aggregate the EVAL
+ * binding state for one AC. Reads:
+ *   - `evalIds`: every EVAL under the parent US whose acIds[] names
+ *     this AC.
+ *   - `evalStatus`: `resolving` | `pending` | `superseded` | `absent`.
+ *     `resolving` = at least one bound EVAL is not superseded AND has
+ *     at least one runRecord[] entry whose verdict is not `pending`.
+ *   - `evalRunVerdict`: the freshest runRecord[] verdict on the
+ *     resolving EVAL: `pass` | `fail` | `pending` | null.
+ *
+ * The consumer (verdict derivation) uses these to decide whether
+ * EVAL-MISSING or EVAL-BELOW-THRESHOLD applies.
+ *
+ * @param {object[]} evals - walker's tree.evals[]
+ * @param {string} usId
+ * @param {string} acId
+ * @returns {{ evalIds: string[], evalStatus: 'resolving'|'pending'|'superseded'|'absent', evalRunVerdict: string|null }}
+ */
+function evalBindingFor(evals, usId, acId) {
+  const bound = (evals ?? []).filter(
+    (e) => e?.usId === usId && Array.isArray(e?.acIds) && e.acIds.includes(acId),
+  );
+  const evalIds = bound.map((e) => e.id);
+  if (bound.length === 0) {
+    return { evalIds: [], evalStatus: 'absent', evalRunVerdict: null };
+  }
+  // Pick the best status: resolving beats pending beats superseded.
+  let bestRank = -1;
+  let bestStatus = 'absent';
+  let bestRunVerdict = null;
+  for (const evalDoc of bound) {
+    let status;
+    let runVerdict = null;
+    if (evalDoc.status === 'superseded') {
+      status = 'superseded';
+    } else {
+      const records = Array.isArray(evalDoc.runRecord) ? evalDoc.runRecord : [];
+      if (records.length === 0) {
+        status = 'pending';
+      } else {
+        const sorted = [...records].sort((a, b) => (a?.runAt ?? '').localeCompare(b?.runAt ?? ''));
+        const latest = sorted[sorted.length - 1];
+        runVerdict = latest?.verdict ?? null;
+        status = runVerdict === 'pending' ? 'pending' : 'resolving';
+      }
+    }
+    const rank = status === 'resolving' ? 3 : status === 'pending' ? 2 : 1;
+    if (rank > bestRank) {
+      bestRank = rank;
+      bestStatus = status;
+      bestRunVerdict = runVerdict;
+    }
+  }
+  return { evalIds, evalStatus: bestStatus, evalRunVerdict: bestRunVerdict };
+}
+
 /**
  * Read the acceptance contract from the chain. Returns the flattened list of
  * acceptance criteria (each mapped back to its user story + requirement — the
@@ -181,6 +238,7 @@ export async function readChain({ repo, chainRef } = {}) {
   const resolvedRef = chainRef ?? tree.prd?.prdId ?? 'PRD-UNKNOWN';
   const fbsItems = tree.fbsItems ?? [];
   const testSuites = tree.testSuites ?? [];
+  const evals = tree.evals ?? [];
   const acs = [];
   for (const us of tree.userStories ?? []) {
     for (const ac of us.acceptanceCriteria ?? []) {
@@ -194,6 +252,15 @@ export async function readChain({ repo, chainRef } = {}) {
         when: ac.when ?? '',
         then: ac.then ?? '',
         testable: ac.testable !== false,
+        // rcf-eval-node spec section 2: `determinism` classification on
+        // each AC (schema-optional; absence resolves to 'deterministic').
+        // Consumed by the eval-coverage derivation below.
+        determinism: ac.determinism ?? 'deterministic',
+        // rcf-eval-node spec sections 5.1 / 5.2: per-AC EVAL binding
+        // aggregate. `evalStatus` is 'resolving' | 'pending' |
+        // 'superseded' | 'absent'; `evalRunVerdict` is the most recent
+        // runRecord verdict on the resolving EVAL, or null.
+        ...evalBindingFor(evals, us.usId, ac.id),
         // 0.7.0 derived fields — verify does the aggregation here per Track A
         // changelog 2026-07-31 and Track B §18 N2 fold; core does not.
         serviceAttestations: serviceAttestationsFor(fbsItems, ac.id),

package/src/verify/cli/run.js

@@ -176,6 +176,21 @@ export async function main(argv, deps = {}) {
     return 1;
   }
 
+  // rcf-eval-node spec section 5.3: preflight-style print for EVAL
+  // coverage. Runs on the report because the engine has already read
+  // the chain; a report re-render carries runStats.evalCoverage so the
+  // same line is reconstructable from the report artefact.
+  const ec = report?.run?.runStats?.evalCoverage ?? report?.runStats?.evalCoverage ?? null;
+  if (ec) {
+    if ((ec.nonDeterministic ?? 0) === 0) {
+      stderr.write('EVAL coverage: no nonDeterministic ACs on this chain\n');
+    } else {
+      stderr.write(
+        `EVAL coverage: nonDeterministic=${ec.nonDeterministic}, covered=${ec.covered}, missing=${ec.missing}\n`,
+      );
+    }
+  }
+
   stderr.write(`[rcf-verify] verdict ${report.verdict} [${report.verdictAuthority}] -> ${flags.out}\n`);
 
   // Exit code is the gate (§8.2). NOT-DEPLOYED / BLOCKED always trip.

package/src/verify/engine/index.js

@@ -179,9 +179,19 @@ export async function runVerification(opts = {}, deps = {}) {
   // (default or overridden) always lands on the report as
   // runStats.playwrightMcpVersion so a report re-render tells the operator
   // which browser tooling this pass ran against (spec 2026-09-03, Q1).
+  // rcf-eval-node spec section 5.3: eval-coverage rollup lands on
+  // runStats so a report re-render surfaces the pass state. Counts
+  // are read off the chain's per-AC evalStatus derivation.
+  const nonDeterministic = chain.acs.filter((a) => a.determinism === 'nonDeterministic');
+  const evalCoverage = {
+    nonDeterministic: nonDeterministic.length,
+    covered: nonDeterministic.filter((a) => a.evalStatus === 'resolving').length,
+    missing: nonDeterministic.filter((a) => a.evalStatus !== 'resolving').length,
+  };
   const runStatsForReport = {
     ...(launchResult?.runStats ?? {}),
     playwrightMcpVersion,
+    evalCoverage,
   };
   const report = buildReport({
     profile, url, parityEnv, reachability, chainRef: chain.chainRef, repo: opts.repo,

package/src/verify/verdict/index.js

@@ -57,12 +57,27 @@ export const VERDICTS = Object.freeze([...FINDING_SEVERITIES, 'NOT-DEPLOYED', 'B
  *     from the finalise-time profile-vs-AC check fires per FBS rather
  *     than only at finalise.
  */
+/*
+ * rcf-eval-node spec 2026-09-04 sections 5.1 + 5.2: two new per-AC
+ * verdicts joining the family without adding to the top-level set:
+ *   - EVAL-MISSING: an AC whose determinism is nonDeterministic and
+ *     which carries no resolving EVAL in the chain at verify time.
+ *     Semantically equivalent to BROWSER-VERIFICATION-MISSING on a
+ *     UI-bearing AC.
+ *   - EVAL-BELOW-THRESHOLD: an AC whose bound EVAL's most recent run
+ *     had verdict `fail` (aggregate below threshold or a critical
+ *     failure). Semantically equivalent to UI-BASELINE-UNMET.
+ * Both refuse `rcf finalise` promotion to `verified` unless the
+ * operator opts out via `--ship-without-eval "<reason>"`.
+ */
 export const PER_AC_VERDICTS = Object.freeze([
   'MOCK-ONLY-DECLARED',
   'BLOCKED-BY-DECLARATION',
   'UI-BASELINE-UNMET',
   'BROWSER-VERIFICATION-MISSING',
   'SCOPE-MISMATCH',
+  'EVAL-MISSING',
+  'EVAL-BELOW-THRESHOLD',
 ]);
 
 /**
@@ -308,6 +323,37 @@ export function derivePerAcVerdicts({ acs = [], browserVerification = [] } = {})
     if (ui) out.push({ acId: ac.acId, verdict: ui.verdict, reason: ui.reason });
     const scopeMismatch = scopePerAcVerdict(ac);
     if (scopeMismatch) out.push({ acId: ac.acId, verdict: scopeMismatch.verdict, reason: scopeMismatch.reason });
+    // rcf-eval-node spec sections 5.1 + 5.4: EVAL-MISSING and
+    // EVAL-BELOW-THRESHOLD fire only for nonDeterministic ACs. A
+    // deterministic AC ships when TS/TC coverage is honest (unchanged);
+    // a nonDeterministic AC additionally requires a resolving EVAL with
+    // a passing latest run.
+    const evalVerdict = evalPerAcVerdict(ac);
+    if (evalVerdict) out.push({ acId: ac.acId, verdict: evalVerdict.verdict, reason: evalVerdict.reason });
   }
   return out;
 }
+
+/**
+ * rcf-eval-node spec sections 5.1 + 5.4. Resolve the per-AC EVAL
+ * verdict for one AC. Deterministic ACs never trigger this verdict.
+ *
+ * @param {object} ac - a flattened AC with `determinism`, `evalStatus`, `evalRunVerdict`
+ * @returns {{ verdict: 'EVAL-MISSING'|'EVAL-BELOW-THRESHOLD', reason: string } | null}
+ */
+export function evalPerAcVerdict(ac) {
+  if (!ac || ac.determinism !== 'nonDeterministic') return null;
+  if (ac.evalStatus !== 'resolving') {
+    return {
+      verdict: 'EVAL-MISSING',
+      reason: `AC ${ac.acId} is nonDeterministic and carries no resolving EVAL (status=${ac.evalStatus ?? 'absent'}); author an EVAL or reclassify the AC as deterministic.`,
+    };
+  }
+  if (ac.evalRunVerdict === 'fail') {
+    return {
+      verdict: 'EVAL-BELOW-THRESHOLD',
+      reason: `AC ${ac.acId} is nonDeterministic and its bound EVAL's most recent run failed (aggregate below threshold or a critical criterion failed); investigate the runRecord or ship with --ship-without-eval.`,
+    };
+  }
+  return null;
+}