fix(review): read the merge-readiness-promoted policy in recordGateScoreSignals (#8223)

The pure gate path applies applyMergeReadinessGate(policy) before evaluating,
so a repo with mergeReadinessGateMode: block and slopGateMode unset genuinely
blocks on slop via the composite promotion -- but the writer read the RAW
policy and skipped the write for exactly that case, silently dropping corpus
evidence. Read every field from the promoted policy, mirroring
recordConfiguredGateBlockerSignals, with a composite-promotion regression test.

Author: RealDiligent

src/rules/advisory.ts

@@ -1159,15 +1159,20 @@ export async function recordGateScoreSignals(
   repoFullName: string,
   prNumber: number,
 ): Promise<void> {
+  // The SAME policy transform evaluateGateCheckCore applies before its pure evaluations: the #551
+  // merge-readiness composite can promote slopGateMode to block, and buildSlopGateBlocker only ever sees
+  // the PROMOTED policy — reading the raw one here would silently drop corpus evidence for exactly the
+  // composite-gated case this capture exists for (mirrors recordConfiguredGateBlockerSignals above).
+  const effective = applyMergeReadinessGate(policy);
   const store = createSignalStore(env);
   const targetKey = `${repoFullName}#${prNumber}`;
   const occurredAt = nowIso();
   const writes: Promise<void>[] = [];
 
-  const slopMode = gateMode(policy.slopGateMode);
-  const slopRisk = normalizeScore(policy.slopRisk);
+  const slopMode = gateMode(effective.slopGateMode);
+  const slopRisk = normalizeScore(effective.slopRisk);
   if (slopMode === "block" && slopRisk !== null) {
-    const slopMin = normalizeScore(policy.slopGateMinScore) ?? DEFAULT_SLOP_BLOCK_THRESHOLD;
+    const slopMin = normalizeScore(effective.slopGateMinScore) ?? DEFAULT_SLOP_BLOCK_THRESHOLD;
     writes.push(
       store
         .recordRuleFired({
@@ -1184,9 +1189,9 @@ export async function recordGateScoreSignals(
     );
   }
 
-  const qualityMode = gateMode(policy.qualityGateMode);
-  const readinessScore = normalizeScore(policy.readinessScore);
-  const qualityMin = normalizeScore(policy.qualityGateMinScore);
+  const qualityMode = gateMode(effective.qualityGateMode);
+  const readinessScore = normalizeScore(effective.readinessScore);
+  const qualityMin = normalizeScore(effective.qualityGateMinScore);
   if (qualityMode !== "off" && readinessScore !== null && qualityMin !== null) {
     writes.push(
       store

test/unit/configured-gate-blocker-signals.test.ts

@@ -267,6 +267,16 @@ describe("recordGateScoreSignals (#8223)", () => {
     expect(history.fired[0]).toMatchObject({ outcome: "below_threshold", metadata: { confidence: 0.3 } });
   });
 
+  it("fires slop under the merge-readiness composite promotion even when slopGateMode itself is unset (#551 parity)", async () => {
+    // mergeReadinessGateMode: block promotes the slop sub-gate to block exactly as evaluateGateCheckCore's
+    // own applyMergeReadinessGate does — the raw slopGateMode stays unset, and the write must still happen.
+    const env = createTestEnv();
+    await recordGateScoreSignals(env, { mergeReadinessGateMode: "block", slopRisk: 72, slopGateMinScore: 60 }, "owner/repo", 7);
+    const history = await createSignalStore(env).queryRuleHistory("slop_gate_score", 0);
+    expect(history.fired).toHaveLength(1);
+    expect(history.fired[0]).toMatchObject({ outcome: "above_threshold", metadata: { confidence: 0.72 } });
+  });
+
   it("records NOTHING for slop outside block mode or with a null risk — the gate never evaluated the score", async () => {
     const env = createTestEnv();
     await recordGateScoreSignals(env, { slopGateMode: "advisory", slopRisk: 72 }, "owner/repo", 7);