synthesis: Phase 6 — tournament-ranked Best-of-N + Inspirations section

Phase 6 of the self-evolving verifier (first phase derived from
external public systems rather than from CE's own register, though
internally aligned with r-bd1386df + r-c2ee5c80).

When a high-novelty cross-reference is promoted to an Insight, the
synthesize step now generates N divergent candidate insights instead
of a single one. Each candidate is canonicalized (Stage 1), scored by
alias-gap to the existing register, and the candidate with the largest
gap wins (ties within ±0.02 broken by self-reported confidence). Pushes
the generator toward structurally distinct candidates instead of
converging on the local attractor — directly addresses the failure
mode the recent reverify exposed (17/18 dark entries downgrading to
extension because the journal converged on a narrow architectural
cluster).

Implementation:
- New SYNTHESIZE_VARIANTS_PROMPT asks for {N} candidates, each with an
  explicit divergence_axis. Single LLM call, batch output.
- New _select_synthesis_candidate() canonicalizes each candidate using
  the existing _canonicalize_central_move (cross-mixin call resolves
  via engine MRO) and computes alias-gap via existing _alias_gap.
- New _build_and_persist_insight() factors out the common Insight
  construction so single-candidate (pre-Phase-6, count==1) and
  Best-of-N paths share construction code.
- New synthesis_candidate_count config knob (default 3, range 1-10).
  Setting to 1 disables Phase 6 entirely (single-candidate behavior).
- Settings UI knob; CLI honors via engine.toml.

Cost: synthesis_candidate_count × synthesis call per qualifying xref.
Default 3× synthesis cost. Bounded — only fires above novelty_threshold.

Borrows tournament-ranking pattern from Google's AI Co-Scientist
(Generation / Reflection / Ranking / Evolution agents) + standard
agentic best-of-N selection.

README:
- Add "Inspirations and prior work" section. Distinguishes Phases 1-5
  (derived from CE's own validated register, the literal self-evolution
  claim) from Phases 6+ (borrowed from public research-agent systems
  where the borrow fits cleanly). Each Phase 6+ borrow names its
  source: Co-Scientist, Sakana AI Scientist, Stanford STORM, Tree of
  Thoughts. Acknowledges general agentic patterns (Claude Code,
  cross-family verification, RAG) and academic lineage (Popperian
  epistemology, Pareto theory, prediction markets). Lists the specific
  combinations that appear genuinely novel (canonical-form alias-gap,
  literature-watch leakage check, freshness probe, append-only
  reverification audit, self-evolving-from-own-register).

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

Author: sfw

README.md

@@ -220,6 +220,59 @@ python curiosity_engine.py --backfill-canonical-forms
 
 ---
 
+## Inspirations and prior work
+
+Two distinct sources have shaped CE's architecture, and they're worth distinguishing.
+
+### Phases 1-5 came from CE's own validated register
+
+The five phases of self-evolution we shipped are not borrowed from external systems — they were derived from validated insights *in the engine's own ideation_on_ideation journal*. Each phase has a source register entry:
+
+- **Phase 1** (canonicalization + alias-gap) ← `r-c67457` (conf 0.82)
+- **Phase 2** (three-stage verifier) ← `r-fcbba1` (conf 0.81)
+- **Phase 3** (component-resolved novelty) ← `r-bedce5b1` (conf 0.79)
+- **Phase 4** (Pareto admission) ← `r-46988c97` (conf 0.78)
+- **Phase 5** (explore/verify space split) ← `r-9a35e387` (conf 0.77)
+
+That is the literal self-evolution claim: the engine identified architectural patterns its own verifier should adopt, and we applied those patterns to the verifier.
+
+### Phases 6+ borrow from comparable public systems
+
+Once the verifier side stabilized, we audited public research-agent systems for ideas the engine could borrow on the *generator* side. Each subsequent phase credits its inspiration:
+
+- **Phase 6** (Best-of-N synthesis with alias-gap ranking) — borrows the **tournament-ranking** pattern from **[Google's AI Co-Scientist](https://research.google/blog/accelerating-scientific-breakthroughs-with-an-ai-co-scientist/)** (Generation / Reflection / Ranking / Evolution agents) plus standard agentic best-of-N selection. Internally aligns with `r-bd1386df` ("cascading structured pairwise tournaments") and `r-c2ee5c80` ("two-player adversarial game over a library") from CE's own register.
+- **Phase 7** (persona-conditioned introspection, planned) — borrows multi-perspective question generation from **[Stanford STORM / Co-STORM](https://github.com/stanford-oval/storm)**. Each persona (skeptic / outsider / historian / contrarian / practitioner) surfaces blind spots the single-voice introspection misses.
+- **Phase 8** (idea evolution from downgraded extensions, planned) — borrows the mutation loop from **[Sakana AI's "AI Scientist"](https://github.com/SakanaAI/AI-Scientist)** and the Evolution agent from Co-Scientist. Internally aligns with `r-3c792e21` ("typed supervision from false positives via retrospective unification") — we treat verifier downgrades as typed supervision signal for generator-side mutation.
+- **Phase 9** (hypothesis variants in investigation, planned) — borrows branching exploration from **[Tree of Thoughts](https://arxiv.org/abs/2305.10601)**. The explorer persona generates N divergent priors; the most-distant-from-majority-literature variant drives the investigation.
+
+### General agentic patterns CE builds on
+
+- **[Claude Code](https://claude.com/claude-code) and the Claude API** — the directive's `Agentic Prompt` block is structured to be pasted directly into Claude Code, MCP orchestrators, or similar LLM-driven agents. The grounding allowlists + tool-call discipline borrow from established agentic patterns.
+- **Cross-family adversarial verification** — the principle that a model evaluating its own output produces no signal is broadly understood; using a different-family model as verifier is standard practice in multi-agent systems. CE's contribution is the *append-only audit trail* + *mechanical guards* on top of cross-family verification, not the cross-family idea itself.
+- **Retrieval-augmented generation patterns** — `academic_search` + `web_fetch` + `archive_access` are standard RAG plumbing.
+
+### Academic / methodological lineage
+
+- **Hypothesis-first investigation** is broadly Popperian / falsificationist epistemology applied to LLM tool use. The mechanical surprise comparison is standard Bayesian-update structure.
+- **Pareto-dominance admission** (Phase 4) is multi-objective optimization theory applied to a register-admission gate.
+- **Negative-space mapping** (the `(method × problem)` matrix) is a long-standing literature-review discipline; CE just instruments it.
+- **Falsifiable predictions with target dates** is descended from prediction-market and forecasting-literature practice (Tetlock, Good Judgement Project, Metaculus).
+
+### Where CE is genuinely novel
+
+Some specific combinations don't appear (to my knowledge) in any public system:
+
+- **Append-only audit trails** with `reverification_log` — most systems mutate state on re-evaluation.
+- **Self-evolving verifier where the engine's own validated insights have been applied to its own architecture** — Phases 1-5 above.
+- **Canonical-form alias-gap detection over a research register** — Phase 1's structural similarity check on `(predicate, substrate, mechanism, target_domain, key_constraints)` tuples is not a pattern I've seen in published agentic systems.
+- **Pareto admission gate over multi-axis register entries** — Phase 4's tournament between *existing* register entries and incoming candidates.
+- **Literature-watch leakage check on directive verification criteria** — preventing the directive from outsourcing its evidence to "by date X a paper appears."
+- **Freshness probe at prediction creation time** — closing the dead-on-arrival case where a "prediction" was already true at creation.
+
+If you're aware of a system that does any of those, please open an issue — I'd want to learn from how they handled it.
+
+---
+
 ## How novelty is verified — the technical detail
 
 ### The problem the verifier is built around

config.py

@@ -180,6 +180,17 @@ class EngineSettings:
     #       can't see.
     # Phase 4 of the self-evolving verifier.
     register_admission_mode: str = "scalar"
+    # Phase 6 of the self-evolving verifier: tournament-ranked Best-of-N
+    # synthesis. When a high-novelty xref is promoted to an Insight, the
+    # synthesize step generates this many candidate insights, canonicalizes
+    # each, and selects the candidate with the largest alias-gap to the
+    # existing register (ties broken by self-reported confidence).
+    # Default 3; minimum effective value is 2 (1 means single-candidate, no
+    # tournament). Higher values trade more LLM cost for more divergent
+    # selection. Cost scales linearly: candidate_count × synthesis call.
+    # Borrows from Co-Scientist's Ranking agent + standard agentic
+    # best-of-N selection patterns.
+    synthesis_candidate_count: int = 3
     # 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
@@ -348,6 +359,9 @@ def load(cls, path: Path = CONFIG_PATH) -> CuriosityEngineConfig:
             register_admission_mode=str(
                 eng_section.get("register_admission_mode", "scalar")
             ).strip().lower() or "scalar",
+            synthesis_candidate_count=max(
+                1, int(eng_section.get("synthesis_candidate_count", 3))
+            ),
             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(),
@@ -722,6 +736,12 @@ def _build_toml(
 # × 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}"
+# Phase 6 — Best-of-N synthesis tournament. When a high-novelty xref is
+# promoted to an Insight, generate this many candidates and select the one
+# with the largest alias-gap to the existing register (ties broken by
+# self-reported confidence). 1 = single-candidate (Phase-6-disabled,
+# matches pre-Phase-6 behavior). 3 = default. Linear LLM cost scaling.
+synthesis_candidate_count = {eng.synthesis_candidate_count}
 # 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/cross_reference.py

@@ -9,7 +9,7 @@
 from uuid import uuid4
 
 from models import CrossReference, Insight
-from prompts import CROSS_REFERENCE_PROMPT, SYNTHESIZE_PROMPT
+from prompts import CROSS_REFERENCE_PROMPT, SYNTHESIZE_PROMPT, SYNTHESIZE_VARIANTS_PROMPT
 
 
 class CrossReferenceMixin:
@@ -215,18 +215,134 @@ def synthesize_orphaned_xrefs(self) -> dict:
         return stats
 
     def synthesize(self, xref: CrossReference) -> Optional[Insight]:
+        """Synthesize an Insight from a cross-reference.
+
+        Phase 6 of the self-evolving verifier: when configured for
+        candidate_count > 1, generate N divergent candidate insights,
+        canonicalize each, and select the candidate with the largest
+        alias-gap to the existing register. Ties broken by self-reported
+        confidence. Borrows from Co-Scientist's Ranking agent + agentic
+        best-of-N selection. Falls back to single-candidate synthesis
+        when synthesis_candidate_count == 1 (pre-Phase-6 behavior).
+        """
         print("\n--- SYNTHESIZING INSIGHT ---")
 
         supporting = [e for e in self.journal.entries if e["id"] in xref.source_entries]
 
-        prompt = SYNTHESIZE_PROMPT.format(
+        candidate_count = max(
+            1, int(getattr(self.connection.engine, "synthesis_candidate_count", 3)),
+        )
+
+        if candidate_count <= 1:
+            # Pre-Phase-6 path: single candidate, no tournament.
+            prompt = SYNTHESIZE_PROMPT.format(
+                focus_block=self._focus_block(),
+                xref_json=json.dumps(asdict(xref), indent=2),
+                supporting_entries_json=json.dumps(supporting, indent=2),
+            )
+            result = self._call_primary(prompt)
+            return self._build_and_persist_insight(result, xref, divergence_axis="")
+
+        # Phase 6: tournament-ranked Best-of-N.
+        prompt = SYNTHESIZE_VARIANTS_PROMPT.format(
             focus_block=self._focus_block(),
             xref_json=json.dumps(asdict(xref), indent=2),
             supporting_entries_json=json.dumps(supporting, indent=2),
+            candidate_count=candidate_count,
+        )
+        try:
+            result = self._call_primary(prompt)
+        except Exception as e:  # noqa: BLE001
+            print(f"  [error] variant synthesis failed: {type(e).__name__}: {e}")
+            return None
+
+        candidates = list(result.get("candidates") or [])
+        if not candidates:
+            print("  [warn] variant synthesis returned no candidates")
+            return None
+
+        print(f"  [tournament] {len(candidates)} candidate(s) generated; scoring by alias-gap…")
+        winner = self._select_synthesis_candidate(candidates, xref)
+        if winner is None:
+            print("  [warn] tournament selected no winner — using highest-confidence candidate as fallback")
+            winner = max(
+                candidates, key=lambda c: float(c.get("confidence", 0) or 0),
+            )
+
+        return self._build_and_persist_insight(
+            winner, xref, divergence_axis=(winner.get("divergence_axis") or "").strip(),
         )
 
-        result = self._call_primary(prompt)
+    def _select_synthesis_candidate(
+        self, candidates: list[dict], xref: CrossReference,
+    ) -> Optional[dict]:
+        """Tournament selector: canonicalize each candidate, score by
+        alias-gap to the existing register, return the most-distant
+        candidate. Confidence breaks ties when alias-gaps are within
+        ALIAS_GAP_TIE_TOLERANCE of each other.
 
+        Falls back to the most-confident candidate if canonicalization
+        produces no usable canonical forms across the cohort.
+        """
+        # ALIAS_GAP_TIE_TOLERANCE — when two candidates' alias-gaps are
+        # within this much of each other, treat them as tied and break
+        # the tie by self-reported confidence. Keeps the tournament from
+        # being decided by tiny embedding-similarity noise.
+        ALIAS_GAP_TIE_TOLERANCE = 0.02
+
+        scored: list[tuple[float, float, int, dict, dict]] = []
+        for idx, c in enumerate(candidates):
+            title = (c.get("title") or "").strip()
+            description = (c.get("description") or "").strip()
+            # Try to canonicalize using a synthetic central_move derived
+            # from the candidate's own title — _canonicalize_central_move
+            # accepts an empty central_move and extracts from description
+            # when needed.
+            try:
+                canonical = self._canonicalize_central_move(
+                    title, description, central_architectural_move=title,
+                )
+            except Exception as e:  # noqa: BLE001 — canonicalization is best-effort
+                print(f"    [warn] canonicalize failed on candidate {idx + 1}: {type(e).__name__}: {e}")
+                canonical = {}
+            # Score: alias-gap if canonical form usable; 0 (worst) otherwise
+            if canonical and canonical.get("move_predicate"):
+                gap_signal = self._alias_gap(canonical)
+                gap = gap_signal.get("gap", 1.0)
+            else:
+                gap = 0.0
+                gap_signal = {"gap": 0.0, "nearest_ids": [], "scored_against": 0}
+            conf = float(c.get("confidence") or 0.0)
+            scored.append((gap, conf, idx, c, canonical))
+            div = (c.get("divergence_axis") or "").strip()[:60]
+            print(
+                f"    candidate {idx + 1}: gap={gap:.2f} conf={conf:.2f}"
+                + (f" · axis={div!r}" if div else "")
+            )
+
+        # Sort by gap desc; among entries within ALIAS_GAP_TIE_TOLERANCE of
+        # the top, prefer the higher confidence.
+        scored.sort(key=lambda s: s[0], reverse=True)
+        best_gap = scored[0][0]
+        tied = [s for s in scored if abs(s[0] - best_gap) <= ALIAS_GAP_TIE_TOLERANCE]
+        if len(tied) > 1:
+            tied.sort(key=lambda s: s[1], reverse=True)
+            print(
+                f"  [tournament] {len(tied)} candidates within "
+                f"{ALIAS_GAP_TIE_TOLERANCE:.2f} of best gap; "
+                "tiebreaking by confidence."
+            )
+        winner = tied[0]
+        winner_idx = winner[2]
+        print(
+            f"  [tournament] winner: candidate {winner_idx + 1} "
+            f"(gap={winner[0]:.2f}, conf={winner[1]:.2f})"
+        )
+        return winner[3]
+
+    def _build_and_persist_insight(
+        self, result: dict, xref: CrossReference, divergence_axis: str = "",
+    ) -> Insight:
         insight = Insight(
             id=f"i-{uuid4().hex[:8]}",
             timestamp=datetime.now(timezone.utc).isoformat(),
@@ -240,12 +356,12 @@ def synthesize(self, xref: CrossReference) -> Optional[Insight]:
             counter_arguments=result.get("counter_arguments", []),
             prior_art_check=result.get("prior_art_check", ""),
         )
-
         self.journal.add_insight(insight)
         print(f"  INSIGHT: {insight.title}")
         print(f"  Confidence: {insight.confidence:.2f}")
+        if divergence_axis:
+            print(f"  Divergence axis (selected): {divergence_axis[:140]}")
         if insight.prior_art_check:
             print(f"  Prior art: {insight.prior_art_check[:120]}...")
         print(f"  {insight.description[:200]}...")
-
         return insight

prompts.py

@@ -632,6 +632,39 @@
 }}"""
 
 
+SYNTHESIZE_VARIANTS_PROMPT = """You are a research engine synthesizing {candidate_count} structurally DIVERGENT candidate insights from the same cross-referenced findings. The system will pick the candidate that is most structurally distant from the existing register — your job is to ensure all candidates are real, defensible, and meaningfully different from each other on a specific architectural axis.
+
+{focus_block}CROSS-REFERENCE:
+{xref_json}
+
+SUPPORTING JOURNAL ENTRIES:
+{supporting_entries_json}
+
+Rules:
+- Each candidate is a standalone insight (title + description + novelty_assessment + ...) AND names its `divergence_axis` — the specific architectural axis on which it differs from the others. Examples of axis shape (NOT for copy-paste): "mechanism: uses X instead of Y", "substrate: acts on A rather than B", "scale: large-N regime vs small-N", "constraint: relaxes assumption Z".
+- Candidates must GENUINELY diverge. If candidate A says "use mechanism X" and candidate B says "use mechanism X with refinement Y", that's NOT divergence — they share the architectural move. They should differ at the architectural level, not at the refinement level.
+- Each candidate honestly reports its `prior_art_check`. Don't pretend a candidate is novel just because the prompt asked for variants — if it's a restatement, say so and lower confidence. The downstream verifier filters for quality; your job is to maximize structural diversity, not to pass verification.
+- No padding. If you cannot produce {candidate_count} genuinely divergent candidates from the source material, return fewer. A list of 2 real divergent candidates beats 3 with one padding entry.
+- Same critical-self-check as single-candidate synthesis: a "novel" insight that merely restates common knowledge poisons the signal — be honest in `prior_art_check` and lower `confidence` accordingly.
+
+Respond with EXACTLY this JSON structure (no other text):
+{{
+  "candidates": [
+    {{
+      "title": "concise statement of the insight (one sentence)",
+      "description": "full articulation of the insight (2-3 paragraphs)",
+      "novelty_assessment": "why you believe this is genuinely novel",
+      "prior_art_check": "honest assessment: is the core claim already well-established?",
+      "confidence": 0.0-1.0,
+      "implications": ["concrete implication 1", "concrete implication 2"],
+      "open_questions": ["what would need to be investigated"],
+      "counter_arguments": ["why this might be wrong"],
+      "divergence_axis": "the specific architectural axis on which this candidate differs from the others"
+    }}
+  ]
+}}"""
+
+
 DIRECTIVE_HYPOTHESIS_PROMPT = """You are composing one section of a RESEARCH DIRECTIVE.
 
 A research directive is a plan a research team executes to take a verified concept from idea to a publishable result. The team runs experiments, gathers data, and produces measurements. The directive is NOT a literature-watch list waiting on other researchers to publish.

web/main.py

@@ -1588,6 +1588,7 @@ def settings_save(
     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_synthesis_candidate_count: int = Form(3),
     engine_analog_probe_max_analogs: int = Form(3),
     engine_assumption_probe_max_assumptions: int = Form(3),
 ):
@@ -1719,6 +1720,7 @@ def _checkbox(v: str) -> bool:
             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"synthesis_candidate_count = {max(1, min(10, engine_synthesis_candidate_count))}\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"
         )