verifier: Pareto admission gate (Phase 4 of self-evolution)

The journal-prescribed insight r-46988c97 (conf 0.78) requires
"living archive admission gated by Pareto dominance across externally
validated axes". Implement the multi-axis admission check and add
register_admission_mode setting to opt in.

Default axis set (4 axes, after distribution-analysis pre-flight):
  - verified_confidence
  - premises_supported_count
  - peer_differentiators_count
  - inverse_alias_gap

known_prior_art_score is excluded by default — it's all-zero on
journals without curated known_prior_art anchors (the common case),
so it would be a Pareto no-op. Re-includable when a journal does
maintain anchors AND verifier evaluations produce differentiator
lists. The full 5-axis dict is still STORED on every entry so
flipping the axis set later doesn't require reverification.

How it works:
  - register_admission_mode = "scalar" (default — backward compat):
    existing single-floor admission unchanged.
  - register_admission_mode = "pareto":
    after the scalar gate approves, also run a Pareto-dominance
    check against existing active entries. Reject the candidate
    if any existing entry beats it on every axis (>= on all,
    strictly > on at least one). Catches "just like X but
    slightly worse on every dimension" admissions the scalar
    floor cannot see.

Implementation:
  - _compute_pareto_axes: single source of truth for the 5-axis
    dict, used by verify_insight (new candidates) and the backfill
    pass (existing entries). Refactor of previously inlined code.
  - _pareto_dominates(existing, candidate): >= on all axes, > on
    at least one. Uses _PARETO_AXES tuple as the axis set.
  - _check_pareto_admission(candidate): O(N) scan of register;
    returns (admitted, dominating_entry_ids).
  - verify_insight: pareto_axes computed once before _register_gate;
    Pareto check runs after gate approves (only when admission_mode
    is pareto). Storage path unchanged (axes always persisted).

Smoke test against the ideation_on_ideation register (21 entries):
  - existing Pareto frontier = 8 entries, each holding ≥1 axis
  - strictly-worse candidate → rejected (dominated by 5 entries)
  - identical-to-r-c6745772 candidate → admitted (Pareto allows ties)
  - mediocre-but-novel-on-alias_gap candidate → admitted via the
    structural-distinctness axis

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: sfw

config.py

@@ -149,6 +149,21 @@ class EngineSettings:
     # confidence on a verdict change is a hedge pattern. This floor keeps
     # stored confidence honest. Set to 0.0 to disable.
     confidence_drop_on_downgrade: float = 0.10
+    # Register admission policy. Two modes:
+    #   "scalar" (default — backward compatible): a candidate is admitted
+    #       iff verdict is validated AND verified_confidence >=
+    #       register_confidence_floor AND premises_supported AND novelty
+    #       isn't restatement/unsupported. Single-axis quality bar.
+    #   "pareto": ALL of the scalar mode's checks PLUS a Pareto-dominance
+    #       check against the existing register. A new candidate is rejected
+    #       if any existing active entry dominates it across the 4-axis
+    #       Pareto set: verified_confidence × premises_supported_count ×
+    #       peer_differentiators_count × inverse_alias_gap. Catches the
+    #       failure mode where a new entry is "just like X but slightly
+    #       worse on every axis" — an admission that the scalar floor
+    #       can't see.
+    # Phase 4 of the self-evolving verifier.
+    register_admission_mode: str = "scalar"
     # Questions below this priority are rejected at enqueue time (except
     # human-sourced questions, which always bypass). Default 0.0 = disabled.
     # An earlier default of 0.70 was found to starve new journals — early
@@ -312,6 +327,9 @@ def load(cls, path: Path = CONFIG_PATH) -> CuriosityEngineConfig:
             question_priority_floor=float(
                 eng_section.get("question_priority_floor", 0.70)
             ),
+            register_admission_mode=str(
+                eng_section.get("register_admission_mode", "scalar")
+            ).strip().lower() or "scalar",
             held_entries_enabled=bool(eng_section.get("held_entries_enabled", True)),
             held_confidence_floor=float(eng_section.get("held_confidence_floor", 0.7)),
             cross_ref_role=str(eng_section.get("cross_ref_role", "")).strip(),
@@ -671,6 +689,13 @@ def _build_toml(
 # before the journal could build context). Set to a non-zero value only on
 # mature journals where you specifically want to prune low-priority noise.
 question_priority_floor = {eng.question_priority_floor}
+# Register admission mode. "scalar" = single confidence floor + status checks
+# (default; backward compatible). "pareto" = ALSO require the new entry to be
+# non-dominated by any existing active entry across the 4-axis Pareto set
+# (verified_confidence × premises_supported_count × peer_differentiators_count
+# × inverse_alias_gap). Pareto rejects "just like X but slightly worse on
+# every axis" admissions that the scalar floor can't see.
+register_admission_mode = "{eng.register_admission_mode}"
 # Held-state pipeline — when the verifier returns `inconclusive` (couldn't reach
 # the claim, not refuted it), insights become held register entries pending
 # settlement rather than being silently rejected. Held entries usually require

engine/verification.py

@@ -304,6 +304,82 @@ def _alias_gap(self, candidate: dict, *, exclude_id: str = "") -> dict:
             "scored_against": scored,
         }
 
+    # ── Pareto admission (Phase 4) ──────────────────────────────────────
+
+    # Default axis set for the Pareto admission gate. Excludes
+    # `known_prior_art_score` because it's degenerate (all-zero) on
+    # journals that have no human-curated known_prior_art anchors —
+    # which is the common case. When a journal does maintain anchors
+    # AND verifier evaluations produce differentiator lists, that
+    # axis can be re-enabled via config (future work; not exposed
+    # in Phase 4).
+    _PARETO_AXES = (
+        "verified_confidence",
+        "premises_supported_count",
+        "peer_differentiators_count",
+        "inverse_alias_gap",
+    )
+
+    @staticmethod
+    def _compute_pareto_axes(
+        *,
+        verified_confidence: float,
+        premises_support_citations: list,
+        closest_peer_system: dict,
+        known_prior_art_evaluations: list,
+        alias_gap: float,
+    ) -> dict:
+        """Single source of truth for an entry's pareto_axes dict.
+        Used by verify_insight (new candidates) and the backfill pass
+        (existing entries). The full 5-axis dict is stored on the entry,
+        even though the default Pareto check uses only 4 axes — keeps
+        future axis tuning possible without re-running verification."""
+        kpa = known_prior_art_evaluations or []
+        return {
+            "verified_confidence": float(verified_confidence),
+            "premises_supported_count": len(premises_support_citations or []),
+            "peer_differentiators_count": len(
+                (closest_peer_system or {}).get("differentiators") or []
+            ),
+            "known_prior_art_score": (
+                float(sum(1 for ev in kpa if ev.get("differentiators")))
+                / max(1.0, len(kpa))
+            ),
+            "inverse_alias_gap": float(alias_gap),
+        }
+
+    @classmethod
+    def _pareto_dominates(cls, existing_axes: dict, candidate_axes: dict) -> bool:
+        """True iff `existing` dominates `candidate` (>= on every axis,
+        AND > on at least one). Missing axes are treated as 0.0."""
+        if not existing_axes or not candidate_axes:
+            return False
+        strict_better = False
+        for axis in cls._PARETO_AXES:
+            e = float(existing_axes.get(axis, 0.0))
+            c = float(candidate_axes.get(axis, 0.0))
+            if e < c:
+                return False  # existing loses on this axis → cannot dominate
+            if e > c:
+                strict_better = True
+        return strict_better
+
+    def _check_pareto_admission(self, candidate_axes: dict) -> tuple[bool, list[str]]:
+        """Returns (admitted, dominating_entry_ids). admitted=True iff no
+        existing register entry dominates the candidate on the configured
+        axis set. Entries without `pareto_axes` populated do not
+        participate in the comparison (they predate Phase 1)."""
+        dominating: list[str] = []
+        for e in self.journal.register:
+            if e.get("status") != "active":
+                continue
+            ex = e.get("pareto_axes") or {}
+            if not ex:
+                continue
+            if self._pareto_dominates(ex, candidate_axes):
+                dominating.append(e.get("id", ""))
+        return (not dominating, dominating)
+
     # ── Component-resolved novelty (Phase 3) ────────────────────────────
 
     @staticmethod
@@ -936,11 +1012,43 @@ def verify_insight(
         peer_has_differentiators = bool(
             closest_peer_system.get("differentiators") or []
         )
+
+        # Phase 4: compute pareto_axes once and persist on every entry
+        # (regardless of admission mode). Even in scalar mode the values
+        # are stored so that flipping admission_mode → pareto later
+        # doesn't require backfilling.
+        pareto_axes = self._compute_pareto_axes(
+            verified_confidence=verified_confidence,
+            premises_support_citations=result.get("premises_support_citations", []) or [],
+            closest_peer_system=closest_peer_system,
+            known_prior_art_evaluations=known_prior_art_evaluations,
+            alias_gap=alias_signal.get("gap", 1.0),
+        )
+
         outcome, entry_status, gate_reasons = self._register_gate(
             verdict, verified_confidence, premises_supported, synthesis_findable,
             novelty_type=novelty_type,
             peer_has_differentiators=peer_has_differentiators,
         )
+
+        # Phase 4: Pareto admission check, applied AFTER the scalar gate
+        # approves. New entry is rejected if any existing active entry
+        # dominates it on the configured axis set. Scalar mode → no-op.
+        admission_mode = (
+            getattr(self.config, "register_admission_mode", "scalar") or "scalar"
+        ).strip().lower()
+        if outcome == "register" and admission_mode == "pareto":
+            admitted, dominating = self._check_pareto_admission(pareto_axes)
+            if not admitted:
+                ids = ", ".join(dominating[:3])
+                more = f" (+{len(dominating) - 3} more)" if len(dominating) > 3 else ""
+                print(
+                    f"  [pareto admission] candidate dominated by {ids}{more} "
+                    f"on axes {list(self._PARETO_AXES)} — rejecting."
+                )
+                outcome = "reject"
+                gate_reasons = list(gate_reasons) + [f"pareto_dominated_by={dominating[:3]}"]
+
         if outcome == "reject":
             print(f"  Not registered ({', '.join(gate_reasons)}).")
             return None
@@ -1009,20 +1117,7 @@ def verify_insight(
             known_prior_art_evaluations=list(known_prior_art_evaluations),
             canonical_form=dict(canonical_form),
             component_novelty=dict(component_novelty),
-            pareto_axes={
-                "verified_confidence": verified_confidence,
-                "premises_supported_count": len(
-                    result.get("premises_support_citations", []) or []
-                ),
-                "peer_differentiators_count": len(
-                    (closest_peer_system.get("differentiators") or [])
-                ),
-                "known_prior_art_score": float(sum(
-                    1 for ev in known_prior_art_evaluations
-                    if ev.get("differentiators")
-                )) / max(1.0, len(known_prior_art_evaluations)),
-                "inverse_alias_gap": alias_signal.get("gap", 1.0),
-            },
+            pareto_axes=pareto_axes,
         )
 
         self.journal.add_register_entry(register_entry)
@@ -1891,20 +1986,13 @@ def backfill_canonical_forms(self, force: bool = False) -> dict:
                     )[:200]
                 )
             if not entry.get("pareto_axes") or force:
-                peer = entry.get("closest_peer_system") or {}
-                kpa = entry.get("known_prior_art_evaluations") or []
-                entry["pareto_axes"] = {
-                    "verified_confidence": float(entry.get("verified_confidence", 0.0)),
-                    "premises_supported_count": len(
-                        entry.get("premises_support_citations", []) or []
-                    ),
-                    "peer_differentiators_count": len(peer.get("differentiators") or []),
-                    "known_prior_art_score": (
-                        float(sum(1 for ev in kpa if ev.get("differentiators")))
-                        / max(1.0, len(kpa))
-                    ),
-                    "inverse_alias_gap": gap,
-                }
+                entry["pareto_axes"] = self._compute_pareto_axes(
+                    verified_confidence=float(entry.get("verified_confidence", 0.0)),
+                    premises_support_citations=entry.get("premises_support_citations", []) or [],
+                    closest_peer_system=entry.get("closest_peer_system") or {},
+                    known_prior_art_evaluations=entry.get("known_prior_art_evaluations") or [],
+                    alias_gap=gap,
+                )
             stats["canonicalized"] += 1
 
         # Persist once at the end — the journal save is atomic so we don't

web/main.py

@@ -1546,6 +1546,7 @@ def settings_save(
     engine_gap_verification_hit_threshold: int = Form(5),
     engine_confidence_drop_on_downgrade: float = Form(0.10),
     engine_question_priority_floor: float = Form(0.70),
+    engine_register_admission_mode: str = Form("scalar"),
     engine_analog_probe_max_analogs: int = Form(3),
     engine_assumption_probe_max_assumptions: int = Form(3),
 ):
@@ -1605,6 +1606,10 @@ def _checkbox(v: str) -> bool:
     if gap_scan_classify_role and gap_scan_classify_role not in known_roles:
         gap_scan_classify_role = ""
 
+    register_admission_mode = engine_register_admission_mode.strip().lower()
+    if register_admission_mode not in ("scalar", "pareto"):
+        register_admission_mode = "scalar"
+
     # Render any extra [models.<name>] profiles back out verbatim — we don't
     # expose them in the web form yet, but we mustn't erase them on save.
     extras_toml = ""
@@ -1667,6 +1672,7 @@ def _checkbox(v: str) -> bool:
             f"gap_verification_hit_threshold = {max(1, min(100, engine_gap_verification_hit_threshold))}\n"
             f"confidence_drop_on_downgrade = {max(0.0, min(0.5, engine_confidence_drop_on_downgrade))}\n"
             f"question_priority_floor = {max(0.0, min(1.0, engine_question_priority_floor))}\n"
+            f'register_admission_mode = "{register_admission_mode}"\n'
             f"analog_probe_max_analogs = {max(1, min(10, engine_analog_probe_max_analogs))}\n"
             f"assumption_probe_max_assumptions = {max(1, min(10, engine_assumption_probe_max_assumptions))}\n"
         )

web/templates/settings.html

@@ -529,6 +529,29 @@ <h3 class="text-xs uppercase tracking-wider text-slate-300 mb-1">Parallel fan-ou
                  value="{{ connection.engine.question_priority_floor }}"
                  class="mt-1 w-32 px-3 py-2 rounded-lg border border-slate-700 bg-slate-900/60 text-sm mono" />
         </label>
+
+        <label class="block md:col-span-3">
+          <span class="text-xs uppercase tracking-wider text-slate-400">register_admission_mode</span>
+          <span class="block text-[11px] text-slate-500">
+            How the engine decides which validated insights enter the durable register.
+            <span class="mono">scalar</span> (default — backward compatible): single confidence floor +
+            status checks. <span class="mono">pareto</span>: ALSO require the new entry to be non-dominated
+            by any existing active entry across the 4-axis Pareto set
+            (<span class="mono">verified_confidence</span> × <span class="mono">premises_supported_count</span> ×
+            <span class="mono">peer_differentiators_count</span> × <span class="mono">inverse_alias_gap</span>).
+            Pareto rejects "just like X but slightly worse on every axis" admissions that the
+            scalar floor can't see. Phase 4 of the self-evolving verifier.
+          </span>
+          <select name="engine_register_admission_mode"
+                  class="mt-1 w-full md:w-64 px-3 py-2 rounded-lg border border-slate-700 bg-slate-900/60 text-sm mono">
+            <option value="scalar" {% if (connection.engine.register_admission_mode or 'scalar') == 'scalar' %}selected{% endif %}>
+              scalar (single confidence floor)
+            </option>
+            <option value="pareto" {% if connection.engine.register_admission_mode == 'pareto' %}selected{% endif %}>
+              pareto (4-axis non-dominated check)
+            </option>
+          </select>
+        </label>
       </div>
     </section>