dialectical-framework 2.0.3__tar.gz → 2.0.4__tar.gz

{dialectical_framework-2.0.3 → dialectical_framework-2.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dialectical-framework
-Version: 2.0.3
+Version: 2.0.4
 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.3 → dialectical_framework-2.0.4}/pyproject.toml

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

@@ -324,12 +324,7 @@ class Consultant:
         if messages:
             self._conversation.load_messages(messages)
         parts = [p for p in (preamble, method_prompt(include_decision)) if p]
-        # 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)
+        self._conversation.set_system_prompt("\n\n".join(parts))
 
     async def chat(self, user_message: str) -> str:
         result = await self._conversation.submit(ChatResponse, user_message)
@@ -367,8 +362,7 @@ 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`: the static instructions ride on the system
-        prompt, the focus is the turn). What it built is
+        (`concerns/view_sketch.py::view_sketch_prompt`). 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.
 
@@ -386,8 +380,7 @@ class Consultant:
         """
         from dialectical_framework.concerns.view_sketch import (
             ViewSketchDto, exploration_view_from_sketch, history_ask,
-            history_text, perspective_from_sketch, view_sketch_focus,
-            view_sketch_instructions)
+            history_text, perspective_from_sketch, view_sketch_prompt)
 
         import asyncio
         import dataclasses
@@ -397,19 +390,19 @@ class Consultant:
 
         level = self._conversation._thinking_kwargs().get("thinking")
         history = self._conversation._messages
-        # 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)
+        # The WHOLE request is the turn's user message, its "Answer with ONE
+        # JSON object" included — by measurement, not habit. For one day
+        # (2026-10-06) the static instructions rode on the system prompt so the
+        # cache would cover them (~$0.007 a card) and only "What to show: ..."
+        # was the turn. First cards did not notice; a RETRY did: its history
+        # already holds "Show me: ..." and the previous drawing in PROSE, and with
+        # a bare focus as the last user turn the model answered in prose too —
+        # 1.75 parse retries a retry card, 4.75 view-turn calls instead of 3,
+        # 33 s instead of 20 (`tests/e2e/probe_view_turn_retry_calls.py`, 8
+        # utterances; the first app had measured the same 4.6 calls and +17 s).
+        # The request->prose pair `history_ask` keeps OUT of the history is the
+        # same trap; the long request as the last turn is what holds the format.
+        request = view_sketch_prompt(focus, self._conversation.settings.component_length)
 
         async def draw() -> ViewSketchDto:
             # Each draw works on a COPY of the history: the turns run in
@@ -417,8 +410,7 @@ 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)
-            sketch_turn.set_system_prompt(system)
-            return await sketch_turn.submit(ViewSketchDto, ask)
+            return await sketch_turn.submit(ViewSketchDto, request)
 
         n = clamp_attempts(attempts)
         # Fully parallel, deliberately. On a COLD cache all N draws write the

{dialectical_framework-2.0.3 → dialectical_framework-2.0.4}/src/dialectical_framework/concerns/tetrad_candidates.py

@@ -129,8 +129,13 @@ async def judge_sketches(
       it picked by position and ties;
     - one call per draft with both statements in it (the same lean prompt):
       73% against 90%, the same winner as this judge in 23/40 — stable with
-      itself, but measuring something else.
-    A cheaper judge has to be measured against this one on that probe first.
+      itself, but measuring something else;
+    - THIS prompt with each reasoning field capped at one short sentence
+      (the score is written before the reasoning, so the cap looked free):
+      output 534 -> 181 tokens a call, but 78% against 90%, scores +0.05, the
+      same winner as this judge in 29/40. The reasoning is not dead weight.
+    A cheaper judge has to be measured against this one on that probe first;
+    the owner closed the cost question at this point (2026-10-06).
     """
 
     async def one(tension: Any) -> Optional[SketchVerdict]:

{dialectical_framework-2.0.3 → dialectical_framework-2.0.4}/src/dialectical_framework/concerns/transformation_generation.py

@@ -248,7 +248,17 @@ class ReSideCompletionDto(BaseModel):
         description="Proactiveness category for Re+"
     )
 
-    # Re- fields
+    # Re- fields. The weak position of the staged generator, measured
+    # 2026-10-06 (`tests/e2e/probe_staged_endpoints.py`, 102 Transformations on
+    # 17 one-tension wheels, read with the theory-faithful `TransitionVerdict`):
+    # Re- valid 49% against Ac- 70%, and it is the LANDING that fails (59%
+    # land in T-; 27% valid on T->A edges). The prompt asked for "the
+    # reflection without the action", which the writer read as "keep watching,
+    # do nothing" — and wherever A is the passive pole, doing nothing is A's
+    # trap, not T's. Two `re_minus_from` / `re_minus_into` fields ahead of these
+    # (the one-shot's fix) moved it within noise and were reverted; the
+    # landing is now named in `_generate_re_side`'s Re- instruction instead.
+    # See docs/dev-notes/one-shot-transformation.md.
     re_minus_headline: str = Field(description="Re- headline (component length)")
     re_minus_statement: str = Field(description="Re- statement (fuller than the headline)")
     re_minus_explanation: str = Field(
@@ -641,7 +651,8 @@ Given their action, what reflection does it trigger that leads to growth?
 
 What happens when their action IS taken in, but nothing you do grounds that reflection?
 - What Re+ ITSELF degenerates into when Ac+ is absent — an overextension of the reflection, not the absence of one
-- Path: the Reflection Perspective's positive regresses you toward your negative
+- Where it LANDS is what makes it Re-: it ends in the A- line of <reflection_perspective> — YOUR OWN trap. It starts from that block's T+ line (the other side's strength); you need not name the start, but the landing must be your trap
+- The common miss: "keep watching and do nothing". When the other side is the passive one, doing nothing just leaves THEIR trap in place (the block's T- line) — that is not Re-. Re- is your reflecting, overdone, carrying YOU into your own trap
 - NOT the same failure as Ac-: Ac- is your action left unreflected, Re- is your reflection left unacted
 - Your Ac+ must CONTRADICT Re- (your positive action opposes this regression)
 - Usually lower insight than Re+

{dialectical_framework-2.0.3 → dialectical_framework-2.0.4}/src/dialectical_framework/concerns/transformation_sketch.py

@@ -32,9 +32,10 @@ state, scored 11/17 on the third-trap auditor where a call that skipped the
 poles and stated the theory loosely scored 0/17 (`one-shot-transformation.md`,
 arms 1 and 2; the auditor is saturated by the either/or instruction, so read
 that as compliance). The endpoint half of the minus definitions was added
-afterwards and, stated in text alone, did NOT land: the first app measured it
-at 14-30% and `tests/e2e/probe_transformation_sketch.py` at 22% / 18% (Ac- /
-Re-). What lands the ends is the DTO, not the sentence: the writer names where
+afterwards and, stated in text alone, did NOT land: valid Ac- / Re- in 30% /
+26% of drafts by the theory-faithful auditor (`probe_transition_rescore.py`;
+the app's stricter auditor read 14-30%). What lands the ends is the DTO, not
+the sentence: the writer names where
 each minus line starts and lands before writing it (`TransformationSketchDto`
 says why and by how much). That probe is the gate for any change to the
 definition text or those fields. Arm 1 is not evidence against the endpoints:
@@ -143,15 +144,25 @@ class TransformationSketchDto(BaseModel):
 
     `ac_minus_from` / `ac_minus_into` (and the Re- pair) come BEFORE their
     line on purpose, and they are the measured fix, not decoration. Stating the
-    ends in the definition does not make the writer use them: the shipped text
-    put Ac- on T+ -> A- in 22% of drafts and Re- on A+ -> T- in 18%, because
-    "the action without the reflection" reads like the tetrad's own "T+ without
-    A+ yields T-" and the line lands on T's OWN trap. Making the writer name
-    the start and the landing first moved both to 60% / 58% (+38 / +40, both
-    clearing noise), with the makeup reads and S- unchanged within noise
-    (`tests/e2e/probe_transformation_sketch.py`, 25 tetrads x 2 reps,
-    2026-10-06). A host may ignore the four scaffold fields; their job is done
-    by the time the line is written.
+    ends in the definition does not make the writer use them: with the text
+    alone a valid Ac- (lands in A-, is the action degenerated, does not start
+    from A+) came back in 30% of drafts and a valid Re- in 26%, because "the
+    action without the reflection" reads like the tetrad's own "T+ without A+
+    yields T-" and the line lands on T's OWN trap. Making the writer name the
+    start and the landing first moved them to 56% / 62% (paired +26 / +36, both
+    clearing noise), S- unchanged within noise (`tests/e2e/probe_transformation_sketch.py`,
+    25 tetrads x 2 reps, 2026-10-06, re-read by `probe_transition_rescore.py`
+    with the auditor three blind theory reviewers agreed with on 51/52 clear
+    cases; the app's stricter auditor had read 22/18% -> 60/58%). A host may
+    ignore the four scaffold fields; their job is done by the time the line is
+    written.
+
+    The price to watch, OPEN: the ends rose and the makeup reads dipped
+    ("Re- is the reflection itself" 94% -> 88% here, within noise; the first
+    app's pill measured 98% -> 80% in its own voice). A line written to land
+    on A+ -> T- can stop reading as the reflection overdone. If a host's
+    makeup read keeps falling, that is a trade to measure on this probe, not
+    a reason to drop the fields by eye.
 
     Hosts SUBCLASS it to add their own person-facing fields after these, so
     the derivation and the words that rest on it stay one call: the first
@@ -270,6 +281,13 @@ class TransformationSketch(ReasonableConcern[TransformationSketchDto], SettingsA
     class: it subclasses `TransformationSketchDto` and embeds
     `TRANSFORMATION_BUILD_PROCEDURE` in its own system prompt, so the theory
     is still the framework's and the voice is the host's.
+
+    A host that writes person-facing text from the result in a SECOND call
+    must tell that call the lines are meaning only, not wording to reuse:
+    otherwise it echoes them, and the lines are written to the theory's
+    shape, not to a person. Measured by the first app on its card text
+    (19–21 points lost until its writer said so; the record is in that app's
+    repo).
     """
 
     def __init__(self) -> None:

{dialectical_framework-2.0.3 → dialectical_framework-2.0.4}/src/dialectical_framework/concerns/view_sketch.py

@@ -186,22 +186,8 @@ 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_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.
+def view_sketch_prompt(focus: Optional[str], max_words: int) -> str:
+    """The structured turn's request, over the consultant's own conversation.
 
     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
@@ -217,20 +203,15 @@ def view_sketch_instructions(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.
 
-{ASPECT_DEFINITIONS}
+{focus_line}{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.
@@ -247,17 +228,6 @@ 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.3 → dialectical_framework-2.0.4}/src/dialectical_framework/utils/edge_context.py

@@ -104,9 +104,42 @@ def build_edge_context(source_segment: WheelSegment, target_segment: WheelSegmen
     if target_t_minus:
         parts.append(f"A-: {target_t_minus[0].prompt_text}")
 
+    if _crosses_tensions(source_segment, target_segment):
+        parts.append(CROSS_TENSION_NOTE)
+
     return "\n".join(parts)
 
 
+#: Said whenever the two segments belong to DIFFERENT tensions — every edge of a
+#: wheel with two or more tensions. The labels above are relative ("A" is just the
+#: target), and at N >= 2 the writer read that "A" as T's own antithesis: on ten
+#: two-tension wheels a third of the staged Ac+ (28% / 35%, two generations) turned
+#: T's trap into T's OWN tension's strength instead of this target's, while a
+#: one-shot prompt carrying this sentence did so in 4% / 18%
+#: (`tests/e2e/probe_n2_one_shot_edge.py`, 2026-10-06). On a one-tension wheel the
+#: target IS the other side of T's tension, so nothing is said there.
+CROSS_TENSION_NOTE = (
+    "(T and A above come from TWO DIFFERENT tensions: do not read A as the other "
+    "side of T's own tension — a move that ends in T's own opposite has not "
+    "reached this A.)"
+)
+
+
+def _crosses_tensions(source_segment: WheelSegment, target_segment: WheelSegment) -> bool:
+    """True when the target is NOT the other side of the source's own tension.
+
+    By the statements, not the perspectives: two readings of one polarity are
+    different perspectives over the SAME tension, and their edge is not a
+    crossing. Unknown (a missing statement) reads as not crossing — the note is
+    an aid, and saying nothing is the old behaviour.
+    """
+    own_other = source_segment.opposite.t.get()
+    target_t = target_segment.t.get()
+    if not own_other or not target_t:
+        return False
+    return own_other[0].hash != target_t[0].hash
+
+
 def build_coarser_context(parents: list[CoarserTransformation]) -> Optional[str]:
     """
     Build hierarchical refinement context from coarser parent Transformations.