dialectical-framework 2.1.1__tar.gz → 2.1.3__tar.gz

{dialectical_framework-2.1.1 → dialectical_framework-2.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dialectical-framework
-Version: 2.1.1
+Version: 2.1.3
 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
@@ -32,7 +32,7 @@ Requires-Dist: broadcaster (>=0.3.1,<0.4.0)
 Requires-Dist: dependency-injector (>=4.48.2,<5.0.0)
 Requires-Dist: gqlalchemy (>=1.8.0,<2.0.0)
 Requires-Dist: langfuse (>=4.5.1,<5.0.0)
-Requires-Dist: mirascope[anthropic,openai,ops] (>=2.5.0,<3.0.0)
+Requires-Dist: mirascope[anthropic,openai,ops] (>=2.8.2,<3.0.0)
 Requires-Dist: python-dotenv (>=1.2.1,<2.0.0)
 Requires-Dist: tabulate (>=0.9.0,<0.10.0)
 Project-URL: Homepage, https://github.com/dialexity/dialectical-framework

{dialectical_framework-2.1.1 → dialectical_framework-2.1.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dialectical-framework"
-version = "2.1.1"
+version = "2.1.3"
 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"
@@ -43,11 +43,17 @@ from = "src"
 
 [tool.poetry.dependencies]
 python = "^3.11"
+# 2.8.2 is the FLOOR, not a preference: below it Mirascope's Anthropic encoder
+# sends extended thinking as the legacy token budget, which every Claude 5 model
+# rejects with a 400 — so a thinking structured call (the view turn, TetradSketch)
+# cannot run on the native `anthropic/` provider at all. The framework's own
+# `thinking_compat` covers this for `bedrock/` only. Measured 2026-10-26, story in
+# docs/dev-notes/antithesis-selection.md.
 mirascope = {extras = [
     "openai",
     "anthropic",
     "ops"
-], version = "^2.5.0"}
+], version = "^2.8.2"}
 python-dotenv = "^1.2.1"
 tabulate = "^0.9.0"
 dependency-injector = "^4.48.2"

{dialectical_framework-2.1.1 → dialectical_framework-2.1.3}/src/dialectical_framework/agents/consultant/consultant.py

@@ -432,6 +432,8 @@ class Consultant:
         import dataclasses
 
         from dialectical_framework.agents.advisor.migration import person_turns
+        from dialectical_framework.concerns.attribution_check import \
+            drop_unborne_holders
         from dialectical_framework.concerns.tetrad_candidates import (
             clamp_attempts, ranking, select_sketch)
 
@@ -505,6 +507,20 @@ class Consultant:
             for drawn_sketch in sketches:
                 if drawn_sketch.tensions:
                     drawn_sketch.tensions[0].thesis = pinned
+                    # A pinned position is the host's own words for the
+                    # person's own position: never someone else's.
+                    drawn_sketch.tensions[0].thesis_held_by = ""
+        # The person's turns, for the judges below. Also the words a named
+        # holder is checked against.
+        words = judge_context(person_turns(history))
+        # A holder the words do not bear is dropped, in code, on every draw
+        # (`concerns/attribution_check.py`, 2026-10-27): the prompt rule
+        # halved the misquotation on pasted material and did not end it, and a
+        # runner-up served later must not carry one either. No call where no
+        # holder is named — the person's own words cost nothing here.
+        firsts_to_check = [s.tensions[0] for s in sketches if s.tensions]
+        for dropped in await drop_unborne_holders(firsts_to_check, words):
+            logger.info("A drawn holder was dropped: %s", dropped)
         # 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
@@ -521,9 +537,14 @@ class Consultant:
             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:
+                # This writer CHOOSES the thesis, so a second judge reads each
+                # draw's T, A and A+ against the person's words — the claim
+                # they would sign, an opposition they have not granted
+                # (`tetrad_candidates.judge_fit`, 2026-10-20). With a pinned T
+                # the first read is the same on every draw and the second
+                # still tells them apart.
                 _best, verdicts = await select_sketch(
-                    [firsts[i] for i in judgeable],
-                    context=judge_context(person_turns(history)),
+                    [firsts[i] for i in judgeable], context=words, fit_against=words
                 )
                 order = ranking(verdicts)
                 sketch = sketches[judgeable[order[0]]]

{dialectical_framework-2.1.1 → dialectical_framework-2.1.3}/src/dialectical_framework/agents/conversation_facilitator.py

@@ -35,7 +35,8 @@ from dialectical_framework.utils.call_census import record_call
 from dialectical_framework.utils.thinking_compat import conversational_round
 from dialectical_framework.utils.retry_accounting import (RetryAccount,
                                                           retry_account)
-from dialectical_framework.utils.use_brain import (prefill_token_kwargs,
+from dialectical_framework.utils.use_brain import (last_structured_reply_text,
+                                                  prefill_token_kwargs,
                                                   retry_transient, use_brain)
 
 from mirascope.llm import FinishReason, TextChunk, ThoughtChunk, ToolOutput
@@ -333,6 +334,15 @@ class ConversationFacilitator(SettingsAware):
         # prefill-sensitive quantity — the one prompt caching can move — is
         # `CallRecord.first_token_seconds` on the turn's first round, not this.
         self.last_submit_first_delta_s: Optional[float] = None
+        # The last STRUCTURED reply of this turn as the model wrote it, before
+        # parsing — the JSON text, or the tool call's arguments as text. `None`
+        # on a turn that made no structured call (a reused written reply, a
+        # mocked one). A DTO that validates can still carry a field the model
+        # cut short and continued in the next one (the first app's handoff,
+        # 2026-10-27); nothing in a parse can see that, but a host's own check
+        # can, and then it needs the bytes to say whether the split was the
+        # writing or the wire. See `use_brain.last_structured_reply_text`.
+        self.last_structured_reply_text: Optional[str] = None
         # Bumped once per submit, and captured by `submit_stream` so its `finally`
         # can tell "this turn is still the current one" from "a turn the consumer
         # walked away from, being finalised now".
@@ -522,6 +532,7 @@ class ConversationFacilitator(SettingsAware):
         self.last_tool_rounds = []
         self.last_submit_seconds = 0.0
         self.last_submit_retries = RetryAccount()
+        self.last_structured_reply_text = None
         # Reset here too although this path can never set it: a facilitator is
         # reused across turns, so without this a non-streaming submit would report
         # the previous STREAMED turn's figure as its own.
@@ -701,6 +712,7 @@ class ConversationFacilitator(SettingsAware):
         self.last_submit_seconds = 0.0
         self.last_submit_retries = RetryAccount()
         self.last_submit_first_delta_s = None
+        self.last_structured_reply_text = None
 
         # Re-entered per await instead of wrapped around the whole generator, and
         # `retry_account` explains why: a contextvar set across a `yield` installs
@@ -1442,6 +1454,8 @@ class ConversationFacilitator(SettingsAware):
             return messages
 
         result = await _llm_call()
+        # Same task as the call, so this is THIS call's text (see use_brain).
+        self.last_structured_reply_text = last_structured_reply_text()
         self._messages.append(
             llm.messages.assistant(
                 self._assistant_history_text(result),

{dialectical_framework-2.1.1 → dialectical_framework-2.1.3}/src/dialectical_framework/concerns/antithesis_extraction.py

@@ -66,7 +66,17 @@ _AwaitedT = TypeVar("_AwaitedT")
 # because the previous ask ("an antithesis that represents Negation of the
 # thesis") was complied with exactly — and at the high rungs exact compliance
 # is a caricature (measured 19/19, `tests/probe_blindspot_paths.py`).
-_OPPOSING_POSITION_ASK = """The antithesis is a POSITION someone holds for its own value, that functionally opposes the role the thesis plays — at this rung's mechanism, in the thesis's own terms. It is not the thesis's absence or degradation restated as a stance. Example: for "Quit my job and start my own company", Negation is "Keep the security and craft of employed work", not "Never quit, stay employed forever"; the second is a caricature nobody holds, and a caricature cannot be developed constructively — rate such a candidate's tetrad potential low rather than dressing it up."""
+#
+# The second failure, the caricature's mirror (2026-10-20, the first app's
+# handoff `docs/dev-notes/antithesis-selection.md`, "The hedge wins on coherence"): "in the thesis's own
+# terms" was complied with exactly too, and when the thesis's own words NAME
+# their opponent and concede it ("not only schools, but also …"), that
+# opponent is the most literal answer — the writer drew it as A on Sonnet 5.5
+# in every configuration, and the card handed the person their own clause as
+# the blind spot they were not seeing. This ask was one-sided: tuned against
+# the strawman end, it had nothing to say about the granted end. UNMEASURED
+# as a rule; the shape is the caricature rule's, in the same place.
+_OPPOSING_POSITION_ASK = """The antithesis is a POSITION someone holds for its own value, that functionally opposes the role the thesis plays — at this rung's mechanism, in the thesis's own terms. It is not the thesis's absence or degradation restated as a stance. Example: for "Quit my job and start my own company", Negation is "Keep the security and craft of employed work", not "Never quit, stay employed forever"; the second is a caricature nobody holds, and a caricature cannot be developed constructively — rate such a candidate's tetrad potential low rather than dressing it up. The mirror failure: an opposition the thesis's own words already name AND concede ("not only X but also Y", "X matters, but …") is seen, not missing — its constructive side is something the person has already granted, and a tetrad built on it shows them their own concession as a blind spot. Rate such a candidate's tetrad potential low as well, and oppose the claim they actually make."""
 
 
 # --- Extraction-specific DTOs ---
@@ -94,7 +104,9 @@ class ModePointResultDto(BaseModel):
             "A is a position someone holds for its own value, it can be developed so "
             "that it also strengthens what T is for (an A+ exists), and it has its own "
             "one-sided failure (an A-). Low: A is T's absence or degradation dressed as "
-            "a position, or a caricature nobody would hold — nothing to develop."
+            "a position, a caricature nobody would hold — nothing to develop — or an "
+            "opposition the thesis's own words already name and concede, whose A+ the "
+            "person has granted."
         ),
     )
     arousal_label: str = Field(
@@ -132,7 +144,8 @@ class OptimumARankingDto(BaseModel):
             "functionally opposes the role the thesis plays; it can be developed so "
             "that it also strengthens what the thesis is for, and it has its own "
             "one-sided failure. Worst = the thesis's absence or degradation dressed "
-            "as a stance, or a caricature nobody holds."
+            "as a stance, a caricature nobody holds, or an opposition the thesis's own "
+            "words already concede."
         )
     )
     reasoning: str = Field(
@@ -542,7 +555,7 @@ Thesis: "{thesis.prompt_text}"
 Candidates:
 {numbered}
 
-The best antithesis is the one most likely to yield a coherent tetrad with the thesis: a POSITION someone holds for its own value that functionally opposes the role the thesis plays — it can be developed constructively so that it also strengthens what the thesis is for, and it has its own one-sided failure. Rank lower any candidate that is the thesis's absence or degradation dressed as a stance, a caricature nobody would hold, or the thesis merely hedged. Return every number exactly once."""
+The best antithesis is the one most likely to yield a coherent tetrad with the thesis: a POSITION someone holds for its own value that functionally opposes the role the thesis plays — it can be developed constructively so that it also strengthens what the thesis is for, and it has its own one-sided failure. Rank lower any candidate that is the thesis's absence or degradation dressed as a stance, a caricature nobody would hold, the thesis merely hedged, or an opposition the thesis's own words already name and concede. Return every number exactly once."""
         try:
             verdict = await self._conversation.isolate().submit(
                 response_model=OptimumARankingDto, user_content=prompt

dialectical_framework-2.1.3/src/dialectical_framework/concerns/attribution_check.py

@@ -0,0 +1,148 @@
+"""
+AttributionCheck: do the words bear the holder a drawn pole names?
+
+WHY A CHECK IN CODE
+===================
+The view turn names WHO holds each pole when it is not the person's own
+(`ViewSketchPerspectiveDto.thesis_held_by` / `antithesis_held_by`, carried as
+`PoleView.held_by`, since 2026-10-26), and a prompt rule says a party is
+named only for a position its own words take (`view_sketch.HOLDER_FROM_THE_WORDS`,
+2026-10-27). Measured on 37 pieces of pasted material, two draws each, the
+rule HALVED the misquotation and did not end it: about one draw in twenty
+still named a party for words the text does not bear — a speaker given the
+inverse of their own position, two sides swapped — and a screen shows that
+as "the Minister's position" over words the Minister never said. Prompt
+enforcement scales with compliance (CLAUDE.md, the machinery leak), so the
+last step is the same shape as the thesis pin: enforced by code after the
+draw, not asked for again.
+
+WHAT IT DOES
+============
+One structured call per NAMED holder, shown the person's words and one pole,
+asked whether the text attributes that position to that party — stated in
+their own words or reported as theirs (a role and the person in it are one
+party). NOT attributed: the holder is dropped, so the pole reads as a built
+opposition (A) or as unattributed (T) instead of a misquotation. Attributed:
+kept. Never a replacement: the judge is not handed the right to put a
+different name on the screen. Free where it matters most — on the person's
+own words every holder is empty and no call is made.
+
+Fail-soft the way the fit judge is: a failed judging KEEPS the holder. The
+alternative, dropping on error, would turn "the Minister's position" into
+"your position" on a provider hiccup, which is the 2026-10-26 defect back.
+A missing holder is also what `held_by` means on the graph path, so a host
+must already handle None.
+
+THE VERDICT'S WORDING IS VERSION 2. Version 1 asked whether the text
+"attributes this position" to the party and, applied to the 130 named
+holders of the gate's WITH-arm draws, dropped 28 — 18 of the 27 the probe's
+own judge had flagged, and 10 it had grounded: it read an elaboration as a
+misquotation ("opponents of trophy hunting" refused "killing for pleasure is
+wrong" because the text says only that the controversy is about the morality
+of hunting for pleasure; a rhetorical question that takes a side was "no
+stance"). A dropped true holder costs what this check exists to prevent in
+reverse — "the Minister's position" shown as "your position" — so version 2
+says a fair condensation of the stance the text gives them is theirs, and
+NOT_ATTRIBUTED is no stance at all, the opposite side, or someone else's.
+
+MEASURED (2026-10-27, `tests/e2e/rescore_attribution_check.py`): see
+`docs/dev-notes/views.md`, "A name on words never said" — applied to the
+saved WITH-arm draws of the holder-rule gate and then live on the 37-case
+finding run.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import Any, Literal, Sequence
+
+from pydantic import BaseModel, Field
+
+from dialectical_framework.agents.conversation_facilitator import \
+    ConversationFacilitator
+
+logger = logging.getLogger(__name__)
+
+
+class AttributionDto(BaseModel):
+    """One verdict; the safe value first (the mocked suite fills the first)."""
+
+    verdict: Literal["attributed", "not_attributed"] = Field(
+        description=(
+            "ATTRIBUTED: the text gives that party this position — stated in their "
+            "own words, reported as what they hold, argue, claim or did, or a fair "
+            "condensation of the stance the text gives them (an opponent of X holds "
+            "that X is wrong; a rhetorical question that takes a side takes it; a "
+            "role and the person in it, or a group and a member named as its voice, "
+            "are one party). Wording that goes a little beyond their words while "
+            "keeping their side is still theirs. NOT_ATTRIBUTED: the text gives that "
+            "party no stance on this at all, gives them the OPPOSITE side, or gives "
+            "this position to someone else; a party who is only described, who "
+            "disagrees with it, or who is merely asked about it does not hold it."
+        )
+    )
+    reasoning: str = Field(
+        description="One sentence: the words that attribute it, or that none do."
+    )
+
+
+class AttributionCheck:
+    """Text-only, graph-free, no report: a check the view turn runs."""
+
+    async def score_texts(
+        self, *, position: str, held_by: str, text: str
+    ) -> AttributionDto:
+        prompt = f"""<text>
+{text}
+</text>
+
+Does this text attribute the following position to {held_by.strip()} — stated in their own words, or reported as what they hold, argue, claim or did?
+
+"{position.strip()}\""""
+        return await ConversationFacilitator().submit(
+            response_model=AttributionDto, user_content=prompt
+        )
+
+
+#: The (pole, holder) attribute pairs a tension carries.
+_POLES = (("thesis", "thesis_held_by"), ("antithesis", "antithesis_held_by"))
+
+
+async def drop_unborne_holders(tensions: Sequence[Any], text: str) -> list[str]:
+    """Blank every named holder the text does not bear, IN PLACE, on every
+    tension given (the winner and the spares alike — a host serving a
+    runner-up must not get the misquotation back). Returns one line per
+    holder dropped, for the log. No call where no holder is named; a failed
+    judging keeps the holder (fail-soft, see the module)."""
+    words = (text or "").strip()
+    if not words:
+        return []
+    jobs: list[tuple[Any, str, str, str]] = []
+    for tension in tensions:
+        for pole, holder_attr in _POLES:
+            holder = (getattr(tension, holder_attr, "") or "").strip()
+            position = (getattr(tension, pole, "") or "").strip()
+            if holder and position:
+                jobs.append((tension, pole, holder_attr, holder))
+
+    async def one(job: tuple[Any, str, str, str]) -> bool:
+        tension, pole, _attr, holder = job
+        try:
+            dto = await AttributionCheck().score_texts(
+                position=getattr(tension, pole), held_by=holder, text=words
+            )
+        except Exception as exc:  # noqa: BLE001 — not judged, the holder stays
+            logger.warning("Checking a pole's holder failed; it stays: %s", exc)
+            return False
+        if not isinstance(dto, AttributionDto):
+            return False
+        return dto.verdict == "not_attributed"
+
+    verdicts = await asyncio.gather(*(one(j) for j in jobs))
+    dropped: list[str] = []
+    for (tension, pole, holder_attr, holder), unborne in zip(jobs, verdicts):
+        if unborne:
+            setattr(tension, holder_attr, "")
+            dropped.append(f"{pole} held_by {holder!r}: the words do not bear it")
+    return dropped

{dialectical_framework-2.1.1 → dialectical_framework-2.1.3}/src/dialectical_framework/concerns/tetrad_candidates.py

@@ -28,6 +28,21 @@ three times". What the handoff found beside it is kept: the ranking reads
 dialectical validity after the pass floor (`ranking`), and the view turn's
 judge reads the person's words (`view_sketch.judge_context`).
 
+The second handoff (2026-10-20, `docs/dev-notes/antithesis-selection.md`, "The hedge wins on coherence")
+found the limit of a coherence-only choice: on a multi-claim input the
+writer drew the claim the person would sign twice in three draws and the
+ranking kept the hedge, because a tetrad about a hedge degenerates more
+coherently than one about a demand, and coherence was all the ranking read.
+So the writers that CHOOSE the thesis (the view turn, the one-shot build)
+ask for a second judge beside the control statements, `ThesisFitCheck`
+(`concerns/thesis_fit_check.py`): is this draw's T the claim they would
+sign, and is its A+ something their words do not already grant. It ranks
+AFTER the pass floor as a yes/no (`SketchVerdict.fits`), so every
+keep-any-passing figure on record stands; it is a selection term, never a
+signal back into generation. The staged writer draws for a GIVEN pair, where
+T and A are the same on every draw, and does not ask. Unmeasured at the time
+of writing — the gates are named on the concern.
+
 What this must NOT become: a loop that optimises against the judge. The judge
 never sees the thesis or antithesis — it scores the four aspects' coherence
 and passes a MIRROR antithesis more readily than a genuine position — so a
@@ -48,12 +63,15 @@ holding a text or an object with `.statement` (`TetradDto`'s `AspectDto`).
 from __future__ import annotations
 
 import asyncio
+import dataclasses
 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.thesis_fit_check import (
+    THESIS_FIT_THRESHOLD, ThesisFitCheck)
 from dialectical_framework.graph.nodes.estimation import \
     CONCEPTUAL_COHERENCE_THRESHOLD
 
@@ -100,6 +118,15 @@ class SketchVerdict:
     handoff). `None` on the DV fields means the judge did not say — a verdict
     built from CC alone — and such a verdict ranks BELOW any with a DV, never
     as a zero (a zero is a claim).
+
+    `thesis_fit` is the second judge's read (`ThesisFitCheck`, 2026-10-20):
+    whether the draw stands on the claim the person would sign, against an
+    opposition they have not already granted. `None` here means the fit
+    judge did NOT run (the caller did not ask, had no words to read against,
+    or the call failed) and the draw ranks as it did before the term existed
+    — the opposite convention from DV's, on purpose: DV's `None` is a verdict
+    the judge gave without it, fit's `None` is no judging at all, and a
+    provider error on one draw must not demote it.
     """
 
     t_plus_without_a_plus: float
@@ -107,6 +134,7 @@ class SketchVerdict:
     reasoning: str = ""
     t_plus_without_a_plus_dv: Optional[float] = None
     a_plus_without_t_plus_dv: Optional[float] = None
+    thesis_fit: Optional[float] = None
 
     @property
     def floor(self) -> float:
@@ -130,6 +158,11 @@ class SketchVerdict:
     def passes(self) -> bool:
         return self.floor >= CONCEPTUAL_COHERENCE_THRESHOLD
 
+    @property
+    def fits(self) -> bool:
+        """Not judged, or judged at or above `THESIS_FIT_THRESHOLD`."""
+        return self.thesis_fit is None or self.thesis_fit >= THESIS_FIT_THRESHOLD
+
 
 def aspect_text(value: Any) -> str:
     """The text of an aspect field: a plain string, or an `AspectDto`'s `.statement`."""
@@ -203,17 +236,61 @@ async def judge_sketches(
     return list(await asyncio.gather(*(one(c) for c in candidates)))
 
 
+async def judge_fit(
+    candidates: Sequence[Any], context: str
+) -> list[Optional[float]]:
+    """`ThesisFitCheck` on every candidate, each on its own (gathered), each
+    read against the words in `context`. One call per draw beside the
+    control statements' two. Fail-soft per candidate: a failed judging is
+    `None` — NOT judged, which `SketchVerdict.fits` treats as fitting. A
+    candidate without a thesis or antithesis (a transition tetrad through
+    `as_control_tetrad`) is not judged either. A draw that names T's holder
+    (`thesis_held_by`, the view turn on pasted material) hands it on, so the
+    judge asks whose claim about the right party."""
+
+    async def one(tension: Any) -> Optional[float]:
+        thesis = aspect_text(getattr(tension, "thesis", "")).strip()
+        antithesis = aspect_text(getattr(tension, "antithesis", "")).strip()
+        if not thesis or not antithesis:
+            return None
+        try:
+            verdict = await ThesisFitCheck().score_texts(
+                thesis=thesis,
+                antithesis=antithesis,
+                a_plus=aspect_text(tension.a_plus),
+                text=context,
+                held_by=(getattr(tension, "thesis_held_by", "") or "").strip(),
+            )
+            return verdict.fit
+        except Exception as exc:  # noqa: BLE001 — degrade to "not judged"
+            logger.warning("Judging a sketch's thesis fit failed; it ranks unjudged: %s", exc)
+            return None
+
+    return list(await asyncio.gather(*(one(c) for c in candidates)))
+
+
 async def select_sketch(
-    candidates: Sequence[Any], context: str = ""
+    candidates: Sequence[Any], context: str = "", fit_against: Optional[str] = None
 ) -> tuple[int, list[Optional[SketchVerdict]]]:
     """Judge every candidate (gathered) and return the index of the best plus
     all verdicts (None where judging failed).
 
     Ranking (`ranking`): the weaker control statement first (the pass rule),
-    then dialectical validity, then the mean coherence, 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.
+    then — with `fit_against` — whether the draw stands on the person's claim
+    against an opposition they have not granted (`judge_fit`, a yes/no), then
+    the floor's value, dialectical validity, the mean coherence, 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.
+
+    `fit_against` is the PERSON's words, for the writers that CHOOSE the
+    thesis (the view turn's `judge_context`, the one-shot build's material):
+    on a given pair every draw has the same T and A and the term would cost
+    N calls to say nothing. It is a separate argument from `context` because
+    the two judges read different things: the control statements take the
+    caller's context (on the build, a paraphrase the Advisor composed), the
+    fit judge must read what the person actually said. Empty or `None` skips
+    the fit judge — it is never asked blind.
 
     ONE candidate is never judged: there is nothing to select among, so
     `attempts=1` costs no extra call.
@@ -221,19 +298,38 @@ async def select_sketch(
     if len(candidates) == 1:
         return 0, [None]
 
-    verdicts = await judge_sketches(candidates, context)
+    words = (fit_against or "").strip()
+    if words:
+        verdicts, fits = await asyncio.gather(
+            judge_sketches(candidates, context), judge_fit(candidates, words)
+        )
+        verdicts = [
+            None if v is None else dataclasses.replace(v, thesis_fit=f)
+            for v, f in zip(verdicts, fits)
+        ]
+    else:
+        verdicts = await judge_sketches(candidates, context)
     return ranking(verdicts)[0], verdicts
 
 
 def ranking(verdicts: Sequence[Optional[SketchVerdict]]) -> list[int]:
-    """Candidate indices best first: the weaker control statement, then
+    """Candidate indices best first: whether the weaker control statement
+    passes, then whether the draw fits the person's claim (`fits`: not
+    judged counts as fitting), then the weaker statement's value, then
     dialectical validity, then the mean coherence, then the earlier draw;
     unjudged last. `[0]` is the winner; the rest are the runners-up in order.
 
-    Why the floor stays FIRST: it is the pass rule, and every best-of-N figure
-    on record (CC 36/40 on the view turn, 30/40 on the build, 26/46 on
-    documents) is a keep-any-passing-draw figure — a term ahead of it would
-    trade those for an unmeasured one. Why DV comes next, ahead of the mean:
+    Why the pass rule stays FIRST: every best-of-N figure on record (CC 36/40
+    on the view turn, 30/40 on the build, 26/46 on documents) is a
+    keep-any-passing-draw figure — a term ahead of it would trade those for
+    an unmeasured one. The fit term sits INSIDE that rule, as a yes/no: among
+    draws that hold, one on the claim the person would sign against an
+    opposition they have not granted beats one on a hedge, however coherent
+    the hedge (2026-10-20, `docs/dev-notes/antithesis-selection.md`, "The hedge wins on coherence"); among
+    draws that fail, the fit decides the same way, so a card with no passing
+    draw still shows the person's claim. A yes/no rather than the score
+    because the floor's VALUE should keep deciding between two draws that
+    both fit, as it did before the term. Why DV comes next, ahead of the mean:
     DV is the paper's acceptance term beside SP (the Advisor's quality floor
     already reads it), and it answers the question the choice is about — of
     two draws that both hold, which is the LIVE tension rather than the
@@ -245,11 +341,19 @@ def ranking(verdicts: Sequence[Optional[SketchVerdict]]) -> list[int]:
     `explorer._causality_probability`), never as a zero.
     """
 
-    def key(index: int) -> tuple[int, float, float, float, int]:
+    def key(index: int) -> tuple[int, bool, bool, float, float, float, int]:
         verdict = verdicts[index]
         if verdict is None:
-            return (0, 0.0, 0.0, 0.0, -index)
+            return (0, False, False, 0.0, 0.0, 0.0, -index)
         dv = verdict.dialectical_validity
-        return (1, verdict.floor, -1.0 if dv is None else dv, verdict.mean, -index)
+        return (
+            1,
+            verdict.passes,
+            verdict.fits,
+            verdict.floor,
+            -1.0 if dv is None else dv,
+            verdict.mean,
+            -index,
+        )
 
     return sorted(range(len(verdicts)), key=key, reverse=True)

{dialectical_framework-2.1.1 → dialectical_framework-2.1.3}/src/dialectical_framework/concerns/tetrad_sketch.py

@@ -159,7 +159,14 @@ class TetradSketch(ReasonableConcern[ViewSketchPerspectiveDto], SettingsAware):
             self._report.summary = f"Sketch failed: {first}"
             raise first
 
-        best, verdicts = await select_sketch(candidates, context or "")
+        # This writer chooses the thesis (or words a given one), so the draws
+        # are ranked by the person's claim as well as by coherence
+        # (`tetrad_candidates.judge_fit`): the fit judge reads the MATERIAL,
+        # the person's own words, where the control statements keep the
+        # caller's `context`; with no material it is skipped.
+        best, verdicts = await select_sketch(
+            candidates, context or "", fit_against=material
+        )
         tension = candidates[best]
         self.verdict = verdicts[best]
         self.alternatives = [