dialectical-framework 2.1.0__tar.gz → 2.1.2__tar.gz

{dialectical_framework-2.1.0 → dialectical_framework-2.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dialectical-framework
-Version: 2.1.0
+Version: 2.1.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
@@ -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.0 → dialectical_framework-2.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dialectical-framework"
-version = "2.1.0"
+version = "2.1.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"
@@ -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.0 → dialectical_framework-2.1.2}/src/dialectical_framework/agents/consultant/consultant.py

@@ -425,11 +425,15 @@ class Consultant:
         """
         from dialectical_framework.concerns.view_sketch import (
             ViewSketchDto, exploration_view_from_sketch, history_ask,
-            history_text, perspective_from_sketch, view_sketch_prompt)
+            history_text, judge_context, perspective_from_sketch,
+            view_sketch_prompt)
 
         import asyncio
         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)
 
@@ -459,7 +463,6 @@ class Consultant:
             sketch_turn._messages = list(history)
             return await sketch_turn.submit(ViewSketchDto, request)
 
-        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
@@ -470,6 +473,13 @@ class Consultant:
         # (`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.
+        n = clamp_attempts(attempts)
+        # The SAME request N times, by measurement: N identical requests draw
+        # the same opposition N times, reworded (the first app, 52/52 cards),
+        # and asking draw 2..N for a different one made the spares differ and
+        # the winner worse (CC 19/40 against 27/40, 2026-10-13,
+        # `tests/e2e/probe_view_turn_ask.py`) — so this is a coherence re-roll,
+        # and a host's "another" served from `runners_up` is a rewording.
         drawn = await asyncio.gather(*(draw() for _ in range(n)), return_exceptions=True)
         sketches = [d for d in drawn if not isinstance(d, BaseException)]
         failures = [d for d in drawn if isinstance(d, BaseException)]
@@ -497,19 +507,45 @@ 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
         # 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).
+        # The judge reads the PERSON's turns as its context (`judge_context`):
+        # it never sees T or A, and called blind — as it was here until
+        # 2026-10-13, while the build and the persisted path passed their
+        # material — it scored the four aspects against nothing.
         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, verdicts = await select_sketch([firsts[i] for i in judgeable])
+                # 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=words, fit_against=words
+                )
                 order = ranking(verdicts)
                 sketch = sketches[judgeable[order[0]]]
                 runners_up = [perspective_from_sketch(firsts[judgeable[i]]) for i in order[1:]]

{dialectical_framework-2.1.0 → dialectical_framework-2.1.2}/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.2/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