dialectical-framework 2.0.0__tar.gz → 2.0.2__tar.gz

{dialectical_framework-2.0.0 → dialectical_framework-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dialectical-framework
-Version: 2.0.0
+Version: 2.0.2
 Summary: A dialectical framework for augmented intelligence. AI reasoning powered with dialectics supports humans in: system optimization (psychology, engineering, business, politics, etc.); dispute resolution (mediation, conflicts, negotiations, etc.); decision-making (dilemmas, challenging situations, win-win, etc.).
 License: MIT
 Keywords: dialectics,dialectical-reasoning,synthesis,thesis-antithesis,ai,artificial-intelligence,llm,reasoning-framework,philosophy,logic,argumentation,conflict-resolution,decision-making,critical-thinking,semantic-graph,mirascope,pydantic,perspectives,polarity-reasoning

{dialectical_framework-2.0.0 → dialectical_framework-2.0.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dialectical-framework"
-version = "2.0.0"
+version = "2.0.2"
 description = "A dialectical framework for augmented intelligence. AI reasoning powered with dialectics supports humans in: system optimization (psychology, engineering, business, politics, etc.); dispute resolution (mediation, conflicts, negotiations, etc.); decision-making (dilemmas, challenging situations, win-win, etc.)."
 authors = ["Evaldas Taroza <evaldas@dialexity.com>"]
 readme = "README.md"

{dialectical_framework-2.0.0 → dialectical_framework-2.0.2}/src/dialectical_framework/agents/consultant/consultant.py

@@ -51,7 +51,7 @@ from dialectical_framework.agents.conversation_facilitator import (
     FROM_SETTINGS, ConversationFacilitator)
 from dialectical_framework.agents.stream_events import StreamEvent
 from dialectical_framework.agents.turn_timing import TurnTiming
-from dialectical_framework.graph.views import ExplorationView
+from dialectical_framework.graph.views import ExplorationView, PerspectiveView
 
 #: Tool verbs → mental acts. These are REWRITES, not drops: dropping every
 #: paragraph that mentions a tool name would also delete the discrimination test
@@ -324,7 +324,12 @@ class Consultant:
         if messages:
             self._conversation.load_messages(messages)
         parts = [p for p in (preamble, method_prompt(include_decision)) if p]
-        self._conversation.set_system_prompt("\n\n".join(parts))
+        # Kept because the view turn's system prompt is this text plus the
+        # static half of its request (`exploration_view`): appending keeps the
+        # head a PREFIX of it, so the chat turns' cached prefix is readable by
+        # the sketch turns instead of each paying for its own.
+        self._system_prompt = "\n\n".join(parts)
+        self._conversation.set_system_prompt(self._system_prompt)
 
     async def chat(self, user_message: str) -> str:
         result = await self._conversation.submit(ChatResponse, user_message)
@@ -362,7 +367,8 @@ class Consultant:
         view shows what has been ESTABLISHED, and where `focus` asks for
         structure not yet worked out ("a perspective for the thesis you
         named") the turn builds it by the method first
-        (`concerns/view_sketch.py::view_sketch_prompt`). What it built is
+        (`concerns/view_sketch.py`: the static instructions ride on the system
+        prompt, the focus is the turn). What it built is
         kept in `messages` as the consultant's own words, so the next turn can
         be asked about a corner it just drew.
 
@@ -380,16 +386,30 @@ class Consultant:
         """
         from dialectical_framework.concerns.view_sketch import (
             ViewSketchDto, exploration_view_from_sketch, history_ask,
-            history_text, view_sketch_prompt)
+            history_text, perspective_from_sketch, view_sketch_focus,
+            view_sketch_instructions)
 
         import asyncio
+        import dataclasses
 
         from dialectical_framework.concerns.tetrad_candidates import (
-            clamp_attempts, select_sketch)
+            clamp_attempts, ranking, select_sketch)
 
         level = self._conversation._thinking_kwargs().get("thinking")
         history = self._conversation._messages
-        request = view_sketch_prompt(focus, self._conversation.settings.component_length)
+        # The request travels in two places, not one. Its static half
+        # (definitions, rules, the build procedure) goes on the SYSTEM prompt,
+        # after this head's own, because that is where the provider's cache
+        # breakpoint sits: as part of the user message it followed the history
+        # and was re-prefilled at full rate on every draw (~1.2k tokens x N a
+        # card, measured 2026-10-06). Only the focus — the person's own ask —
+        # is the turn. Same words, and the history record is untouched
+        # (`history_ask`, which is why the long request was never kept anyway).
+        system = (
+            f"{self._system_prompt}\n\n"
+            f"{view_sketch_instructions(self._conversation.settings.component_length)}"
+        )
+        ask = view_sketch_focus(focus)
 
         async def draw() -> ViewSketchDto:
             # Each draw works on a COPY of the history: the turns run in
@@ -397,9 +417,20 @@ class Consultant:
             # read. What the view leaves behind is appended once, below.
             sketch_turn = ConversationFacilitator(format_mode="json", thinking=level)
             sketch_turn._messages = list(history)
-            return await sketch_turn.submit(ViewSketchDto, request)
+            sketch_turn.set_system_prompt(system)
+            return await sketch_turn.submit(ViewSketchDto, ask)
 
         n = clamp_attempts(attempts)
+        # Fully parallel, deliberately. On a COLD cache all N draws write the
+        # ~12k system head instead of one writing and the rest reading (~$0.06
+        # a card at list prices, 2026-10-06), and the fix would be to await the
+        # first draw before firing the rest — but these turns do not stream, so
+        # nothing here can tell a cold cache from a warm one, and the stagger
+        # would spend a whole draw's latency (~6 s) on EVERY card to save money
+        # on the rare one. The 1h breakpoint TTL
+        # (`utils/bedrock_provider.py::_CACHE_TTL`) attacks the same cost
+        # without the latency, which is the trade taken. Revisit only with a
+        # measured cold-start rate.
         drawn = await asyncio.gather(*(draw() for _ in range(n)), return_exceptions=True)
         sketches = [d for d in drawn if not isinstance(d, BaseException)]
         if not sketches:
@@ -407,19 +438,24 @@ class Consultant:
         # With several draws the framework's own coherence check picks the one
         # whose FIRST tension holds best (`concerns/tetrad_candidates.py`); a
         # draw with no complete first tension sorts last. The card a blindspot
-        # screen shows is that first tension.
+        # screen shows is that first tension. The judged draws that lost come
+        # back too, best first, as `runners_up` — a host's "again"/"another"
+        # can serve one without a new call (the module's stated intent).
+        runners_up: list[PerspectiveView] = []
         if len(sketches) > 1:
             firsts = [s.tensions[0] if s.tensions else None for s in sketches]
             judgeable = [i for i, t in enumerate(firsts) if t is not None and all(
                 (getattr(t, k) or "").strip() for k in ("thesis", "antithesis", "t_plus", "t_minus", "a_plus", "a_minus"))]
             if len(judgeable) > 1:
-                best_among, _verdicts = await select_sketch([firsts[i] for i in judgeable])
-                sketch = sketches[judgeable[best_among]]
+                _best, verdicts = await select_sketch([firsts[i] for i in judgeable])
+                order = ranking(verdicts)
+                sketch = sketches[judgeable[order[0]]]
+                runners_up = [perspective_from_sketch(firsts[judgeable[i]]) for i in order[1:]]
             else:
                 sketch = sketches[judgeable[0]] if judgeable else sketches[0]
         else:
             sketch = sketches[0]
-        view = exploration_view_from_sketch(sketch)
+        view = dataclasses.replace(exploration_view_from_sketch(sketch), runners_up=runners_up)
         # What the turn leaves behind is NOT what it sent: the long request and
         # the DTO come off, and the person's ask plus the drawing in words go
         # on. Kept as a request→prose pair, the long request taught the next

{dialectical_framework-2.0.0 → dialectical_framework-2.0.2}/src/dialectical_framework/agents/conversation_facilitator.py

@@ -429,6 +429,12 @@ class ConversationFacilitator(SettingsAware):
                 str((p.get("text") if isinstance(p, dict) else getattr(p, "text", "")) or "")
                 for p in parts
             )
+        elif isinstance(content, dict) and content.get("type") == "text":
+            # A SYSTEM message's content is ONE text part, not a list, and the
+            # documented recipe (`dataclasses.asdict`) renders it as a dict —
+            # the shape a host's saved history carries for the prompt at
+            # position 0 (found by the first app's backend, 2026-10-05).
+            text = str(content.get("text") or "")
         elif isinstance(content, str) or content is None:
             text = content or ""
         else:

{dialectical_framework-2.0.0 → dialectical_framework-2.0.2}/src/dialectical_framework/concerns/control_statements_check.py

@@ -32,7 +32,7 @@ from __future__ import annotations
 
 import asyncio
 from dataclasses import dataclass
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional, Sequence
 
 from pydantic import BaseModel, Field
 
@@ -97,6 +97,107 @@ class CoherenceEvaluationDto(BaseModel):
     )
 
 
+class TetradCoherenceDto(BaseModel):
+    """One tetrad's two control statements, from the JOINT call.
+
+    No DV field, deliberately. DV is an annotation that only `resolve`
+    persists (`DialecticalValidityEstimation`) and nothing reads it when
+    choosing among drafts — `SketchVerdict` has no DV term — so asking for it
+    here would buy output tokens and nothing else. A draft that goes on to be
+    persisted is scored by `resolve` afterwards, DV and all.
+    """
+
+    tetrad: int = Field(
+        description=(
+            "The number of the tetrad this verdict scores, exactly as labelled "
+            "in the request."
+        )
+    )
+    t_plus_without_a_plus_yields_t_minus: float = Field(
+        ge=0.0,
+        le=1.0,
+        description="Conceptual Coherence (0.0-1.0) of that tetrad's statement (a).",
+    )
+    a_plus_without_t_plus_yields_a_minus: float = Field(
+        ge=0.0,
+        le=1.0,
+        description="Conceptual Coherence (0.0-1.0) of that tetrad's statement (b).",
+    )
+    reasoning: str = Field(
+        description=(
+            "One sentence on the weaker of that tetrad's two statements. A note, "
+            "not an essay."
+        )
+    )
+
+
+class JointCoherenceEvaluationDto(BaseModel):
+    """Every tetrad of one request, scored in one call."""
+
+    verdicts: list[TetradCoherenceDto] = Field(
+        description=(
+            "One entry per tetrad in the request, in the request's order. Score "
+            "every tetrad; omit none."
+        )
+    )
+
+
+@dataclass(frozen=True)
+class TetradTexts:
+    """The four aspect texts of one tetrad — all the control statements need.
+
+    What `score_texts_many` takes, so a caller holding several drafts as text
+    cannot mix up the order of four positional strings.
+    """
+
+    t_plus: str
+    t_minus: str
+    a_plus: str
+    a_minus: str
+
+
+def control_statements(
+    *, t_plus: str, t_minus: str, a_plus: str, a_minus: str
+) -> tuple[str, str]:
+    """The paper's two control statements, built from four texts.
+
+    One builder for all three askers (`resolve` off a committed Perspective,
+    `score_texts` and `score_texts_many` off bare texts) so the quoting cannot
+    drift: a verdict taken before persistence and one taken after must be the
+    same question asked of the same words.
+    """
+    return (
+        f'"{t_plus}" without "{a_plus}" yields "{t_minus}"',
+        f'"{a_plus}" without "{t_plus}" yields "{a_minus}"',
+    )
+
+
+# --- Shared prompt text ---
+#
+# Written once because two prompts ask for it: one statement at a time
+# (`_evaluate_control_statement`, for `resolve` and `score_texts`) and all of
+# several tetrads at once (`score_texts_many`). Re-typed inline the scales
+# would drift, and a verdict from one prompt is ranked against a verdict from
+# the other (`concerns/tetrad_candidates.py`).
+
+_PATTERN = """The pattern "[Positive] without [Balancing factor] yields [Negative]" tests whether
+the absence of a balancing positive aspect naturally leads to the negative/shadow aspect."""
+
+_CC_SCALE = """Conceptual Coherence (CC) — is the statement logically meaningful?
+- 0.9-1.0: Highly coherent, clear logical/causal relationship
+- 0.7-0.9: Coherent, reasonable logical connection
+- 0.5-0.7: Somewhat coherent, plausible but weak
+- 0.3-0.5: Weak coherence, tenuous connection
+- 0.0-0.3: Not coherent, no clear logical relationship"""
+
+_DV_SCALE = """Dialectical Validity (DV) — is the dialectical relationship natural, judged
+independently of coherence? A statement can be perfectly coherent yet dialectically
+distorted (e.g. one pole arbitrarily privileged, outcomes enforced by coercion or
+ideology rather than natural system dynamics). 1.0 = natural, balanced, generative;
+0.0 = forced, artificial, distorted. Ignore factual correctness; evaluate only the
+quality of the dialectical relationship as a generative principle."""
+
+
 # --- Result ---
 
 
@@ -182,8 +283,12 @@ class ControlStatementsCheck(ReasonableConcern[ControlStatementsCheckResult]):
         a_minus = perspective.get_component(POSITION_A_MINUS)
 
         # Build control statements
-        stmt_1 = f'"{t_plus.prompt_text}" without "{a_plus.prompt_text}" yields "{t_minus.prompt_text}"'
-        stmt_2 = f'"{a_plus.prompt_text}" without "{t_plus.prompt_text}" yields "{a_minus.prompt_text}"'
+        stmt_1, stmt_2 = control_statements(
+            t_plus=t_plus.prompt_text,
+            t_minus=t_minus.prompt_text,
+            a_plus=a_plus.prompt_text,
+            a_minus=a_minus.prompt_text,
+        )
 
         # Evaluate both statements in parallel using isolated conversations
         result_1, result_2 = await asyncio.gather(
@@ -267,18 +372,90 @@ class ControlStatementsCheck(ReasonableConcern[ControlStatementsCheckResult]):
         """The two control statements on bare texts — no Perspective, no graph.
 
         What `resolve` does after reading the four aspects off a committed
-        node, offered to callers that hold a tetrad as text: the best-of-N
-        selector (`concerns/tetrad_candidates.py`) and the harness. Built with
-        the same quoting as `resolve`'s statements so a verdict here is the
-        same question as the one asked after persistence.
+        node, for a caller holding ONE tetrad as text and wanting DV with it.
+        Built by the same statement builder as `resolve`, so a verdict here is
+        the same question as the one asked after persistence.
+
+        Not what best-of-N selection uses: a field of drafts goes through
+        `score_texts_many`, which asks once for all of them and leaves DV out
+        (nothing in selection reads it). Two statements, two calls, both with
+        reasoning, is the shape that made judging a third of a card's cost.
         """
-        stmt_1 = f'"{t_plus}" without "{a_plus}" yields "{t_minus}"'
-        stmt_2 = f'"{a_plus}" without "{t_plus}" yields "{a_minus}"'
+        stmt_1, stmt_2 = control_statements(
+            t_plus=t_plus, t_minus=t_minus, a_plus=a_plus, a_minus=a_minus
+        )
         return await asyncio.gather(
             self._evaluate_control_statement(stmt_1, text),
             self._evaluate_control_statement(stmt_2, text),
         )
 
+    async def score_texts_many(
+        self,
+        tetrads: Sequence[TetradTexts],
+        *,
+        text: str = "",
+    ) -> list[Optional[TetradCoherenceDto]]:
+        """Several tetrads' control statements, all in ONE call.
+
+        What `score_texts` asks for one draft at a time, asked for a whole
+        best-of-N field at once. Measured reason (2026-10-06, the first app's
+        real entry points through `utils/call_census.py`): per-statement calls
+        made judging 6 of the 11 provider calls behind one card and ~3.3k of
+        its ~5.1k output tokens — about a third of the card's cost — because
+        each call spent ~550 output tokens of reasoning on one sentence. One
+        call with a short note per tetrad replaces six.
+
+        The question is unchanged and so is its discipline: the judge sees
+        only each tetrad's four aspects (never the thesis or antithesis, see
+        `concerns/tetrad_candidates.py`), the statements are built by the same
+        builder `resolve` uses, and the prompt forbids comparing the drafts —
+        selection stays among independent draws. CC only; `TetradCoherenceDto`
+        says why DV is not asked for here.
+
+        Fail-soft per tetrad: a verdict the model omits, or labels with a
+        number that is out of range or already filled, comes back `None` for
+        that tetrad rather than shifting every later one onto the wrong draft.
+        """
+        if not tetrads:
+            return []
+
+        blocks = []
+        for n, tetrad in enumerate(tetrads, 1):
+            stmt_a, stmt_b = control_statements(
+                t_plus=tetrad.t_plus,
+                t_minus=tetrad.t_minus,
+                a_plus=tetrad.a_plus,
+                a_minus=tetrad.a_minus,
+            )
+            blocks.append(f"Tetrad {n}:\n(a) {stmt_a}\n(b) {stmt_b}")
+
+        context_section = f"<context>\n{text}\n</context>\n\n" if text else ""
+        joined = "\n\n".join(blocks)
+        prompt = f"""{context_section}Rate the control statements of {len(tetrads)} tetrads. Each tetrad has two statements, (a) and (b).
+
+{joined}
+
+{_PATTERN}
+
+Rate every statement on one scale:
+
+{_CC_SCALE}
+
+Score each tetrad on its own, against the pattern above and nothing else. These are independent drafts: do not compare them with each other, do not rank them, do not pick a best, and do not let one tetrad's wording move another's score. The order they appear in carries no information. Return one verdict per tetrad, labelled with that tetrad's number."""
+
+        conversation = ConversationFacilitator()
+        result = await conversation.submit(
+            response_model=JointCoherenceEvaluationDto,
+            user_content=prompt,
+        )
+
+        placed: list[Optional[TetradCoherenceDto]] = [None] * len(tetrads)
+        for verdict in result.verdicts:
+            index = verdict.tetrad - 1
+            if 0 <= index < len(placed) and placed[index] is None:
+                placed[index] = verdict
+        return placed
+
     async def _evaluate_control_statement(
         self,
         statement: str,
@@ -291,22 +468,11 @@ class ControlStatementsCheck(ReasonableConcern[ControlStatementsCheckResult]):
 
 {statement}
 
-The pattern "[Positive] without [Balancing factor] yields [Negative]" tests whether
-the absence of a balancing positive aspect naturally leads to the negative/shadow aspect.
+{_PATTERN}
 
-1. Conceptual Coherence (CC) — is the statement logically meaningful?
-- 0.9-1.0: Highly coherent, clear logical/causal relationship
-- 0.7-0.9: Coherent, reasonable logical connection
-- 0.5-0.7: Somewhat coherent, plausible but weak
-- 0.3-0.5: Weak coherence, tenuous connection
-- 0.0-0.3: Not coherent, no clear logical relationship
+1. {_CC_SCALE}
 
-2. Dialectical Validity (DV) — is the dialectical relationship natural, judged
-independently of coherence? A statement can be perfectly coherent yet dialectically
-distorted (e.g. one pole arbitrarily privileged, outcomes enforced by coercion or
-ideology rather than natural system dynamics). 1.0 = natural, balanced, generative;
-0.0 = forced, artificial, distorted. Ignore factual correctness; evaluate only the
-quality of the dialectical relationship as a generative principle."""
+2. {_DV_SCALE}"""
 
         conversation = ConversationFacilitator()
         return await conversation.submit(

{dialectical_framework-2.0.0 → dialectical_framework-2.0.2}/src/dialectical_framework/concerns/tetrad_candidates.py

@@ -31,13 +31,12 @@ holding a text or an object with `.statement` (`TetradDto`'s `AspectDto`).
 
 from __future__ import annotations
 
-import asyncio
 import logging
 from dataclasses import dataclass
 from typing import Any, Optional, Sequence
 
-from dialectical_framework.concerns.control_statements_check import \
-    ControlStatementsCheck
+from dialectical_framework.concerns.control_statements_check import (
+    ControlStatementsCheck, TetradTexts)
 from dialectical_framework.graph.nodes.estimation import \
     CONCEPTUAL_COHERENCE_THRESHOLD
 
@@ -106,49 +105,96 @@ def is_complete(candidate: Any) -> bool:
     )
 
 
-async def judge_sketch(tension: Any, context: str = "") -> SketchVerdict:
-    """The validator's two control statements, on the candidate's texts, graph-free.
-
-    Statement texts are built exactly as `ControlStatementsCheck.resolve`
-    builds them from committed Statements, so a verdict here and one taken
-    after persistence are the same question asked of the same words.
+async def judge_sketches(
+    candidates: Sequence[Any], context: str = ""
+) -> list[Optional[SketchVerdict]]:
+    """The validator's two control statements for EVERY candidate, in ONE call.
+
+    Statement texts are built by the same builder `ControlStatementsCheck.resolve`
+    uses, so a verdict here and one taken after persistence are the same
+    question asked of the same words. The judge still sees only the four
+    aspects of each draft — never the thesis or the antithesis — and the
+    prompt forbids comparing the drafts with each other, so selection stays
+    "among independent draws" (this module's docstring) and this call cannot
+    be turned into regeneration.
+
+    Why one call: judging used to be a call per control statement per
+    candidate — 6 of the 11 provider calls behind one best-of-3 card, and
+    ~3.3k of its ~5.1k output tokens, about a third of its cost (measured
+    2026-10-06 on the first app's real entry points with
+    `utils/call_census.py`). One call with a short note per tetrad replaces
+    six long ones.
+
+    Fail-soft twice over. A verdict the model omits is `None` for that
+    candidate, which sorts last; a failed call leaves EVERY candidate
+    unjudged, which keeps the first draw — exactly what `attempts=1` would
+    have done. The second shape is new with the joint call and is the cost of
+    it: per-statement calls could lose one candidate's verdict and keep the
+    rest.
+
+    OPEN, because this was a cost change and not a quality one. Judge
+    stability was 92% on re-judging the same text when each statement had its
+    own call (`docs/dev-notes/antithesis-selection.md`, "Best-of-N"); the
+    joint call's stability, and its position bias (a candidate winning for
+    being listed first), are unmeasured — measure both with the same probe,
+    and the card quality with the app's paired eval, before reading any
+    quality claim into this. If stability falls below ~85%, the rung down is
+    one call per candidate with both statements in one DTO, which is still
+    half the output of the per-statement shape.
     """
-    first, second = await ControlStatementsCheck().score_texts(
-        t_plus=aspect_text(tension.t_plus),
-        t_minus=aspect_text(tension.t_minus),
-        a_plus=aspect_text(tension.a_plus),
-        a_minus=aspect_text(tension.a_minus),
-        text=context,
-    )
-    return SketchVerdict(
-        t_plus_without_a_plus=first.coherence_score,
-        a_plus_without_t_plus=second.coherence_score,
-        reasoning=f"{first.reasoning} / {second.reasoning}".strip(" /"),
-    )
+    try:
+        verdicts = await ControlStatementsCheck().score_texts_many(
+            [
+                TetradTexts(
+                    t_plus=aspect_text(c.t_plus),
+                    t_minus=aspect_text(c.t_minus),
+                    a_plus=aspect_text(c.a_plus),
+                    a_minus=aspect_text(c.a_minus),
+                )
+                for c in candidates
+            ],
+            text=context,
+        )
+    except Exception as exc:  # noqa: BLE001 — degrade to "all unjudged"
+        logger.warning("Judging the sketches failed; the first draw is kept: %s", exc)
+        return [None] * len(candidates)
+    return [
+        None
+        if v is None
+        else SketchVerdict(
+            t_plus_without_a_plus=v.t_plus_without_a_plus_yields_t_minus,
+            a_plus_without_t_plus=v.a_plus_without_t_plus_yields_a_minus,
+            reasoning=v.reasoning,
+        )
+        for v in verdicts
+    ]
 
 
 async def select_sketch(
     candidates: Sequence[Any], context: str = ""
 ) -> tuple[int, list[Optional[SketchVerdict]]]:
-    """Judge every candidate (gathered) and return the index of the best plus
-    all verdicts (None where judging failed).
+    """Judge every candidate (one call) and return the index of the best plus
+    all verdicts (None where a verdict did not come back).
 
     Ranking: the weaker control statement first (the pass rule), then the
     mean, then the earlier draw — a deterministic tie-break, not a preference.
-    A candidate whose judging failed sorts last; if every judging failed the
-    first draw is kept, which is exactly what `attempts=1` would have done.
+    An unjudged candidate sorts last; if no verdict came back at all the first
+    draw is kept, which is exactly what `attempts=1` would have done.
+
+    ONE candidate is never judged: there is nothing to select among, so
+    `attempts=1` costs no extra call.
     """
     if len(candidates) == 1:
         return 0, [None]
 
-    async def one(tension: Any) -> Optional[SketchVerdict]:
-        try:
-            return await judge_sketch(tension, context)
-        except Exception as exc:  # noqa: BLE001 — degrade to "unjudged"
-            logger.warning("Judging a sketch failed; it sorts last: %s", exc)
-            return None
+    verdicts = await judge_sketches(candidates, context)
+    return ranking(verdicts)[0], verdicts
+
 
-    verdicts = list(await asyncio.gather(*(one(c) for c in candidates)))
+def ranking(verdicts: Sequence[Optional[SketchVerdict]]) -> list[int]:
+    """Candidate indices best first, by `select_sketch`'s rule: the weaker
+    control statement, then the mean, then the earlier draw; unjudged last.
+    `[0]` is the winner; the rest are the runners-up in order."""
 
     def key(index: int) -> tuple[int, float, float, int]:
         verdict = verdicts[index]
@@ -157,5 +203,4 @@ async def select_sketch(
         mean = (verdict.t_plus_without_a_plus + verdict.a_plus_without_t_plus) / 2
         return (1, verdict.floor, mean, -index)
 
-    best = max(range(len(candidates)), key=key)
-    return best, verdicts
+    return sorted(range(len(verdicts)), key=key, reverse=True)

{dialectical_framework-2.0.0 → dialectical_framework-2.0.2}/src/dialectical_framework/concerns/view_sketch.py

@@ -186,8 +186,22 @@ For each pair:
 3. Re-read both aspects against step 1 for two distinct failures. (a) Wrong parent: if one is really the OTHER parent developed, rewrite it from its own parent. (b) {PLUS_RESTATEMENT_CHECK}"""
 
 
-def view_sketch_prompt(focus: Optional[str], max_words: int) -> str:
-    """The structured turn's request, over the consultant's own conversation.
+def view_sketch_focus(focus: Optional[str]) -> str:
+    """The one per-call line of the request: what this draw is to show.
+
+    Split from the instructions so the Consultant can send this alone as the
+    turn's user message and carry the static half on the system prompt, where
+    the provider's cache breakpoint already sits (`view_sketch_instructions`).
+    """
+    return (
+        f"What to show: {focus}"
+        if focus and focus.strip()
+        else "What to show: the tensions this conversation has worked out so far."
+    )
+
+
+def view_sketch_instructions(max_words: int) -> str:
+    """The STATIC half of the view turn's request — everything but the focus.
 
     Two instructions in one, because the ask is one or the other and the model
     knows which: render what is ESTABLISHED (a tension already named and taken
@@ -203,15 +217,20 @@ def view_sketch_prompt(focus: Optional[str], max_words: int) -> str:
     (docs/dev-notes/antithesis-selection.md, 2026-10-02). The thesis is asked
     for as a STANCE (`THESIS_IS_A_STANCE`): on 20 questions the turn echoed the
     question as T in 6 before the ask was here (the alsotrue app repo, docs/lab-notes-entry.md).
+
+    Static because every word of it is fixed per deployment (`max_words` comes
+    from settings), which is what lets the Consultant append it to its system
+    prompt: as a user message it sat after the history and was re-prefilled at
+    full rate on every draw — ~1.2k tokens x N per card, measured 2026-10-06.
+    On the system prompt it rides inside the cached prefix. This is a cache
+    placement, not a content change; the one thing it does move is WHERE the
+    focus line sits, from just under the opening paragraph to the end of the
+    turn (`tests/e2e/probe_view_turn_ask.py` is the instrument if that is ever
+    suspected of mattering).
     """
-    focus_line = (
-        f"What to show: {focus}\n\n"
-        if focus and focus.strip()
-        else "What to show: the tensions this conversation has worked out so far.\n\n"
-    )
     return f"""Draw the structure of this conversation as dialectical tetrads. Answer with ONE JSON object in the requested schema and nothing else — no prose. Earlier drawings in this conversation are recorded in prose; that is their record, not the format of this answer.
 
-{focus_line}{ASPECT_DEFINITIONS}
+{ASPECT_DEFINITIONS}
 
 Rules for what goes in the view:
 - Show what this conversation has ESTABLISHED: a tension you named and the person took up is drawn as you both have it, in their terms. Do not re-derive what is already on the table.
@@ -228,6 +247,17 @@ Rules for what goes in the view:
 Write every position in the person's own terms, {max_words} words or fewer each."""
 
 
+def view_sketch_prompt(focus: Optional[str], max_words: int) -> str:
+    """The whole request as ONE user message: the instructions and the focus.
+
+    The shape for a caller with no system prompt of its own to append to — the
+    probes and the harness. The Consultant sends the two halves apart
+    (`view_sketch_instructions` on the system prompt, `view_sketch_focus` as
+    the turn), which is the same words in a different place.
+    """
+    return f"{view_sketch_instructions(max_words)}\n\n{view_sketch_focus(focus)}"
+
+
 # --- The view shaping (pure) ----------------------------------------------
 
 

{dialectical_framework-2.0.0 → dialectical_framework-2.0.2}/src/dialectical_framework/graph/views.py

@@ -339,12 +339,18 @@ class ExplorationView:
     perspectives: list[PerspectiveView] = field(default_factory=list)
     #: The Nexus this is a view of; None when it is the whole case.
     nexus_hash: Optional[str] = None
+    #: The best-of-N draws that lost, best first — the first tension of each
+    #: (`concerns/tetrad_candidates.py`: "returned, not thrown away"). A
+    #: host's "again"/"another" can show one without a new reasoning call.
+    #: Empty for a view read off the graph, or drawn once.
+    runners_up: list[PerspectiveView] = field(default_factory=list)
 
     def without_terminology(self) -> ExplorationView:
         return dataclasses.replace(
             self,
             perspectives=[p.without_terminology() for p in self.perspectives],
             nexus_hash=None,
+            runners_up=[p.without_terminology() for p in self.runners_up],
         )
 
     def to_dict(self) -> dict[str, Any]: