dialectical-framework 1.6.6__tar.gz → 1.6.7__tar.gz

{dialectical_framework-1.6.6 → dialectical_framework-1.6.7}/PKG-INFO

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

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

@@ -17,8 +17,8 @@ from typing import AsyncGenerator, Optional
 
 from pydantic import BaseModel, Field
 
-from dialectical_framework.agents.advisor.system_prompts import (
-    SYSTEM_PROMPT, system_prompt)
+from dialectical_framework.agents.advisor.system_prompts import \
+    system_prompt
 from dialectical_framework.agents.agent_context import agent_scope
 from dialectical_framework.agents.conversation_facilitator import \
     ConversationFacilitator
@@ -144,13 +144,13 @@ class Advisor:
             dialectical_context
             or "No prior understanding — this is a fresh conversation."
         )
-        if self._nexus_hash:
-            engine = system_prompt(
-                tool_names=[t.__name__ for t in self._tools],
-                scoped_nexus_hash=self._nexus_hash,
-            )
-        else:
-            engine = SYSTEM_PROMPT
+        # Rendered at construction (not the import-time SYSTEM_PROMPT
+        # constant) so settings-derived prompt values (max_wheel_layer)
+        # reflect the live DI configuration.
+        engine = system_prompt(
+            tool_names=[t.__name__ for t in self._tools],
+            scoped_nexus_hash=self._nexus_hash,
+        )
         parts.append(engine.replace("{dialectical_context}", context_text))
 
         return "\n\n".join(parts)

{dialectical_framework-1.6.6 → dialectical_framework-1.6.7}/src/dialectical_framework/agents/advisor/system_prompts.py

@@ -34,6 +34,51 @@ def _ladder_lines(scale: dict[str, float], annotations: dict[float, str]) -> str
     return "\n".join(lines)
 
 
+def _resolve_max_wheel_layer() -> int:
+    """The live settings.max_wheel_layer, falling back to the Pydantic field
+    default when DI isn't wired (e.g. the import-time SYSTEM_PROMPT render).
+    """
+    from dialectical_framework.settings import Settings
+
+    try:
+        from dialectical_framework.protocols.has_config import SettingsAware
+
+        value = SettingsAware().settings.max_wheel_layer
+        if isinstance(value, int) and value >= 1:
+            return value
+    except Exception:
+        pass
+    return Settings.model_fields["max_wheel_layer"].default
+
+
+def _nexus_evolution(cap: int) -> str:
+    """Render the explore doc's 'How a nexus evolves' ladder from the live
+    wheel-layer cap (settings.max_wheel_layer), so the prompt's nexus-size
+    guidance never drifts from what PerspectiveCombination actually builds.
+    """
+    lines = [
+        "  How a nexus evolves:",
+        "  - 1 perspective: a single self-referential wheel. Already generates",
+        "    transformations and synthesis — useful even alone.",
+    ]
+    if cap >= 2:
+        lines += [
+            "  - 2 perspectives: the causal question emerges (which thesis enables which?).",
+            "    Produces multiple wheels (arrangements), each with its own pathways.",
+        ]
+    if cap >= 3:
+        span = f"3-{cap}" if cap > 3 else "3"
+        lines += [
+            f"  - {span} perspectives: richer causal chains, more transformation variety,",
+            "    deeper synthesis. The sweet spot for insight.",
+        ]
+    lines.append(
+        f"  - >{cap}: combinatorial explosion — arrangements aren't built beyond"
+        f" {cap} perspectives; start a new nexus for more tensions."
+    )
+    return "\n".join(lines)
+
+
 _ROLE = """## Role
 
 You are in conversation with someone navigating a decision, tension, or
@@ -277,14 +322,7 @@ _TOOL_DOCS: dict[str, str] = {
   and sibling nexuses on one theme fragment the pathways. Create separate
   nexuses only for genuinely distinct themes.
 
-  How a nexus evolves:
-  - 1 perspective: a single self-referential wheel. Already generates
-    transformations and synthesis — useful even alone.
-  - 2 perspectives: the causal question emerges (which thesis enables which?).
-    Produces multiple wheels (arrangements), each with its own pathways.
-  - 3-4 perspectives: richer causal chains, more transformation variety,
-    deeper synthesis. The sweet spot for insight.
-  - >4: combinatorial explosion — cap at 4, start a new nexus for more tensions.
+{nexus_evolution}
 
   Grouping principle: prefer perspectives from different polarities (different
   T-A oppositions) — transformations between them represent genuine synthesis
@@ -314,11 +352,15 @@ _TOOL_DOCS: dict[str, str] = {
   them. Deepening only adds analytical depth to existing structure — it
   never changes what the exploration contains, so no consent ceremony is
   needed. Harmless on already-developed wheels.""",
-    "sync": """- `sync` — Re-reads the full graph state. Use when you need a fresh full
-  picture — e.g., after multiple ingest/anchor calls, to see all perspectives
-  with scores before deciding what to group for explore. NOT needed after every
-  tool call (ingest/anchor/explore return their results directly), and NOT
-  needed at conversation start — the full state is already in your context.""",
+    "sync": """- `sync` — Re-reads the graph state. Without arguments: the full picture —
+  e.g., after multiple ingest/anchor calls, to see all perspectives with
+  scores before deciding what to group for explore. With a `nexus_hash`:
+  zooms into that one exploration in full depth — the overview caps wheels
+  per cycle for compactness, the zoom does not. Zoom when counsel settles on
+  one exploration and you need arrangements the overview truncated. NOT
+  needed after every tool call (ingest/anchor/explore return their results
+  directly), and NOT needed at conversation start — the full state is
+  already in your context.""",
     "sync_scoped": """- `sync` — Re-reads this exploration's state. Use when you need a fresh
   picture after changes. NOT needed at conversation start — the exploration
   is already in your context.""",
@@ -485,6 +527,22 @@ Use `inspect_node` when you want to understand the reasoning behind a score,
 explain WHY a specific blindspot exists, or ground a pathway recommendation
 in the actual analytical logic rather than restating the dump.
 
+**Cross-exploration correspondences.** When several explorations coexist,
+some perspectives carry correspondence lines — machine-stated facts, not
+suggestions: "Also woven into Nexus [[x]]" (literally the same tension in
+both explorations) and "Same opposition family (...) as perspective N in
+[[x]]" (both tensions anchored to the same deep-structure category). These
+are your invitation to draw parallels across the person's situations —
+often the most powerful counsel move available: the same structural dynamic
+playing out in two arenas of their life means an insight earned in one
+transfers to the other. But family-level correspondence is coarse (few
+families exist, collisions are common) — before drawing the parallel, check
+it holds in substance: read both tetrads and confirm the dynamics actually
+mirror each other, not just the category. The family name itself (Integrity,
+Fire, ...) is framework vocabulary — the How You Speak rules above govern
+it like any other; by default, name what the two tensions share in the
+person's own terms, not the category label.
+
 **Sequences are circular causality.** Both Cycle and Wheel sequences are
 closed loops — they start and end with the same element (e.g., "T1 → T2 → T1..."
 or "T1 → A2 → A1 → T2 → T1..."). The "..." indicates the circle continues.
@@ -520,6 +578,13 @@ Use these scores to prioritize what you draw on:
 - `rectangularity`: Tetrad balance (lower = better).
   <0.01 = well-balanced. 0.01–0.09 = mild imbalance, acceptable.
   >0.09 = one side overdeveloped — note the imbalance.
+- `DV`: Dialectical validity — how NATURAL the tension's dynamics are
+  (higher = the poles genuinely complement each other and the pathologies
+  arise organically; lower = the framing is forced, one-sided, or held
+  together by coercion/ideology rather than natural dynamics). Comparative
+  signal, no fixed cutoff: prefer high-DV tensions when choosing what to
+  build counsel on, and treat a low-DV tension as a hint the framing itself
+  may be distorted — consider re-anchoring rather than polishing aspects.
 - `Ks` on aspects: Complementarity toward synthesis.
   T+/A+ should be >0.4 (constructive poles complement the whole).
   T-/A- should be <0.6 (destructive poles don't overpower).
@@ -549,12 +614,13 @@ Use these scores to prioritize what you draw on:
 
 **Prioritization rules:**
 
-The dump is pre-pruned: tensions below the quality floor (weak opposition,
-blurred structure, failed validation) and low-probability wheels are already
-suppressed — count lines note what was filtered. Everything you see passed
-the floor; you rank within it, you don't re-filter.
+The dump is pre-pruned: tensions below the quality floors (weak opposition,
+blurred structure, unnatural/distorted framing, failed validation) and
+low-probability wheels are already suppressed — count lines note what was
+filtered. Everything you see passed the floors; you rank within them, you
+don't re-filter.
 
-1. Lead with the strongest tensions (highest HS on A, best area). Softer
+1. Lead with the strongest tensions (highest HS on A, best area, best DV). Softer
    ones are still visible by design — usable, and they may resonate with
    the person's lived experience, but don't build your primary counsel
    around them.
@@ -635,7 +701,13 @@ def system_prompt(
         # Scoped variants of sync/explore have their own doc text.
         key = f"{name}_scoped" if scoped and f"{name}_scoped" in _TOOL_DOCS else name
         if key in _TOOL_DOCS:
-            tool_docs.append(_TOOL_DOCS[key])
+            doc = _TOOL_DOCS[key]
+            if "{nexus_evolution}" in doc:
+                doc = doc.replace(
+                    "{nexus_evolution}",
+                    _nexus_evolution(_resolve_max_wheel_layer()),
+                )
+            tool_docs.append(doc)
 
     conversation_use = _CONVERSATION_USE
     if scoped and "ingest" not in names:

dialectical_framework-1.6.7/src/dialectical_framework/agents/advisor/tools/sync.py

@@ -0,0 +1,32 @@
+"""
+sync tool: Re-read the dialectical graph state.
+
+Returns a structured dump of tensions, pathways, and synthesis for the
+current case scope. With `nexus_hash`, zooms into one exploration and
+renders it in full depth (the unscoped dump caps wheels per cycle for
+compactness; the zoomed render is exempt, same as counsel-mode dumps).
+"""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+from mirascope import llm
+from pydantic import Field
+
+from dialectical_framework.concerns.dialectical_context import \
+    DialecticalContext
+
+
+@llm.tool
+async def sync(
+    nexus_hash: Annotated[
+        str | None,
+        Field(
+            description="Zoom into one exploration: render only this nexus, in full depth (no wheel cap). Omit for the full-case overview."
+        ),
+    ] = None,
+) -> str:
+    """Re-read the graph state. Without arguments: the full picture across all explorations (compact — wheels capped per cycle). With a nexus_hash: one exploration in full depth. Use the zoom when counsel centers on one exploration and the overview's capped view isn't enough."""
+    concern = DialecticalContext(nexus_hash=nexus_hash)
+    return await concern.resolve()

{dialectical_framework-1.6.6 → dialectical_framework-1.6.7}/src/dialectical_framework/agents/orchestrator/tools/inspect_node.py

@@ -149,6 +149,8 @@ from pydantic import Field
 
 from dialectical_framework.agents.reasonable_concern import ReasonableConcern
 from dialectical_framework.enums.di import DI
+from dialectical_framework.graph.nodes.estimation import \
+    DialecticalValidityEstimation
 from dialectical_framework.graph.rendering import (
     build_pp_index,
     component_alias,
@@ -215,7 +217,11 @@ def _inspect_perspective(pp: Perspective) -> str:
     # Tetrad quality metrics
     diff_t = pp.diff_t
     diff_a = pp.diff_a
-    area = pp.area_normalized
+    # Raw area (= theory's SP, -2..2) — the scale every band/gate/prompt in the
+    # system speaks (settings min_sp, advisor bands, dialectical_context).
+    # area_normalized (area/2) is a UI-only hint; showing it here under a
+    # different scale than the Advisor's dump confused cross-surface reads.
+    area = pp.area
     rect = pp.rectangularity
     metrics: list[str] = []
     if diff_t is not None:
@@ -223,9 +229,15 @@ def _inspect_perspective(pp: Perspective) -> str:
     if diff_a is not None:
         metrics.append(f"diff_a={diff_a:.3f}")
     if area is not None:
-        metrics.append(f"area_normalized={area:.3f}")
+        metrics.append(f"area={area:.3f}")
     if rect is not None:
         metrics.append(f"rect={rect:.4f}")
+    # DV (Dialectical Validity, paper's naturalness companion to SP) — read
+    # from the persisted estimation, annotation only.
+    for est, _ in pp.estimations.all():
+        if isinstance(est, DialecticalValidityEstimation):
+            metrics.append(f"DV={est.value:.3f}")
+            break
     if metrics:
         lines.append(f"Quality: {', '.join(metrics)}")
 

{dialectical_framework-1.6.6 → dialectical_framework-1.6.7}/src/dialectical_framework/concerns/action_extraction.py

@@ -111,8 +111,9 @@ APEX
 2. Must help transition FROM T- (problem) TOWARD A+ (benefit)
 3. Must NOT simply restate A+ - it's the PATH, not the destination
 4. Should be generative: enable discovery rather than prescribe specific outcomes
-5. Length: a fuller actionable form, longer than the headline
-6. Choose the insight level that best matches the nature of the action
+5. Must stay subtle, not forceful: an action that imposes, coerces, or overpowers reverses its polarity from Ac+ to Ac-. Prefer enabling over forcing
+6. Length: a fuller actionable form, longer than the headline
+7. Choose the insight level that best matches the nature of the action
 """
 
 

{dialectical_framework-1.6.6 → dialectical_framework-1.6.7}/src/dialectical_framework/concerns/control_statements_check.py

@@ -42,7 +42,8 @@ from dialectical_framework.agents.reasonable_concern import \
     ReasonableConcern
 from dialectical_framework.agents.execution_report import ExecutionReport
 from dialectical_framework.graph.nodes.estimation import (
-    CONCEPTUAL_COHERENCE_THRESHOLD, ConceptualCoherenceEstimation)
+    CONCEPTUAL_COHERENCE_THRESHOLD, ConceptualCoherenceEstimation,
+    DialecticalValidityEstimation)
 from dialectical_framework.graph.nodes.rationale import Rationale
 from dialectical_framework.graph.nodes.perspective import (POSITION_A_MINUS,
                                                           POSITION_A_PLUS,
@@ -57,7 +58,16 @@ if TYPE_CHECKING:
 
 
 class CoherenceEvaluationDto(BaseModel):
-    """Result of evaluating a single control statement."""
+    """Result of evaluating a single control statement (CC + DV).
+
+    DESIGN FORK (revisit if scores correlate): CC and DV are scored in the SAME
+    LLM call here (zero extra cost), while the paper [P1 S1.7] used separate
+    prompts per metric. Same-call scoring risks the model anchoring one score
+    on the other. If real-LLM checks against the paper's reference table
+    (S1.7-1/-2: Orwellian DV≈0.0 with CC as high as 0.85 on some models;
+    Buddhist DV≈0.9) show CC and DV tracking each other where the paper
+    separates them, split DV into its own call (+2 calls per perspective).
+    """
 
     coherence_score: float = Field(
         ge=0.0,
@@ -65,6 +75,26 @@ class CoherenceEvaluationDto(BaseModel):
         description="Logical coherence score (0.0-1.0). >= 0.7 is considered coherent.",
     )
     reasoning: str = Field(description="Brief explanation of the coherence assessment")
+    dialectical_validity: float = Field(
+        ge=0.0,
+        le=1.0,
+        description=(
+            "Dialectical Validity (DV, 0.0-1.0), judged INDEPENDENTLY of coherence. "
+            "1.0 = the statement expresses a natural, balanced, generative dialectical "
+            "relationship: the concepts occupy comparable semantic levels, the two "
+            "positive poles genuinely complement one another, and the predicted "
+            "pathology arises naturally from the absence of its complementary "
+            "counterpart. 0.0 = forced, artificial, or dialectically distorted: "
+            "semantically mismatched concepts, one pole arbitrarily privileged, or "
+            "outcomes relying on coercion, ideology, arbitrary conventions, or "
+            "implausible reasoning rather than natural system dynamics. Ignore "
+            "factual correctness; evaluate only the quality of the dialectical "
+            "relationship as a generative principle."
+        ),
+    )
+    dv_reasoning: str = Field(
+        description="Brief explanation of the dialectical-validity assessment"
+    )
 
 
 # --- Result ---
@@ -79,6 +109,7 @@ class ControlStatementsCheckResult:
     """
 
     estimation: ConceptualCoherenceEstimation
+    dv_estimation: DialecticalValidityEstimation
     rationale: Rationale
 
     # Control statement details for transparency
@@ -88,6 +119,9 @@ class ControlStatementsCheckResult:
     a_plus_without_t_plus_yields_a_minus_statement: str
     a_plus_without_t_plus_yields_a_minus_score: float
     a_plus_without_t_plus_yields_a_minus_reasoning: str
+    # DV per statement (annotation only — never gates; see DialecticalValidityEstimation)
+    t_plus_without_a_plus_yields_t_minus_dv: float
+    a_plus_without_t_plus_yields_a_minus_dv: float
 
     @property
     def is_coherent(self) -> bool:
@@ -159,29 +193,39 @@ class ControlStatementsCheck(ReasonableConcern[ControlStatementsCheckResult]):
 
         # Create estimation and rationale nodes
         avg_score = (result_1.coherence_score + result_2.coherence_score) / 2
+        avg_dv = (result_1.dialectical_validity + result_2.dialectical_validity) / 2
 
         estimation = ConceptualCoherenceEstimation(
             value=avg_score,
             t_plus_without_a_plus_yields_t_minus=result_1.coherence_score,
             a_plus_without_t_plus_yields_a_minus=result_2.coherence_score,
         )
+        dv_estimation = DialecticalValidityEstimation(
+            value=avg_dv,
+            t_plus_without_a_plus_yields_t_minus=result_1.dialectical_validity,
+            a_plus_without_t_plus_yields_a_minus=result_2.dialectical_validity,
+        )
         status = "COHERENT" if estimation.is_coherent else "NOT COHERENT"
 
         rationale_text = (
             f"Conceptual Coherence Evaluation: {status}\n\n"
-            f"T+ without A+ yields T- (score={result_1.coherence_score:.2f}):\n"
+            f"T+ without A+ yields T- (CC={result_1.coherence_score:.2f}, DV={result_1.dialectical_validity:.2f}):\n"
             f"  {stmt_1}\n"
-            f"  Reasoning: {result_1.reasoning}\n\n"
-            f"A+ without T+ yields A- (score={result_2.coherence_score:.2f}):\n"
+            f"  Reasoning: {result_1.reasoning}\n"
+            f"  DV reasoning: {result_1.dv_reasoning}\n\n"
+            f"A+ without T+ yields A- (CC={result_2.coherence_score:.2f}, DV={result_2.dialectical_validity:.2f}):\n"
             f"  {stmt_2}\n"
-            f"  Reasoning: {result_2.reasoning}\n\n"
-            f"Coherence requires both scores >= {CONCEPTUAL_COHERENCE_THRESHOLD} (average: {avg_score:.2f})"
+            f"  Reasoning: {result_2.reasoning}\n"
+            f"  DV reasoning: {result_2.dv_reasoning}\n\n"
+            f"Coherence requires both CC scores >= {CONCEPTUAL_COHERENCE_THRESHOLD} (average: {avg_score:.2f}).\n"
+            f"DV (dialectical naturalness, avg {avg_dv:.2f}) annotates only — no threshold."
         )
         rationale = Rationale(text=rationale_text)
 
         # Only commit and attach if PP is committed
         if perspective.is_committed:
             estimation.set_target(perspective)
+            dv_estimation.set_target(perspective)
             rationale.set_explanation_target(perspective)
             rationale.commit()
             self._report.node_created(rationale)
@@ -190,8 +234,13 @@ class ControlStatementsCheck(ReasonableConcern[ControlStatementsCheckResult]):
             estimation.commit()
             self._report.node_created(estimation)
 
+            dv_estimation.set_provider(rationale)
+            dv_estimation.commit()
+            self._report.node_created(dv_estimation)
+
         result = ControlStatementsCheckResult(
             estimation=estimation,
+            dv_estimation=dv_estimation,
             rationale=rationale,
             t_plus_without_a_plus_yields_t_minus_statement=stmt_1,
             t_plus_without_a_plus_yields_t_minus_score=result_1.coherence_score,
@@ -199,6 +248,8 @@ class ControlStatementsCheck(ReasonableConcern[ControlStatementsCheckResult]):
             a_plus_without_t_plus_yields_a_minus_statement=stmt_2,
             a_plus_without_t_plus_yields_a_minus_score=result_2.coherence_score,
             a_plus_without_t_plus_yields_a_minus_reasoning=result_2.reasoning,
+            t_plus_without_a_plus_yields_t_minus_dv=result_1.dialectical_validity,
+            a_plus_without_t_plus_yields_a_minus_dv=result_2.dialectical_validity,
         )
 
         self._build_report(result)
@@ -212,19 +263,26 @@ class ControlStatementsCheck(ReasonableConcern[ControlStatementsCheckResult]):
         """Evaluate a single control statement for logical coherence."""
         context_section = f"<context>\n{text}\n</context>\n\n" if text else ""
 
-        prompt = f"""{context_section}Rate the logical coherence of this control statement:
+        prompt = f"""{context_section}Rate this control statement on two independent scales:
 
 {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.
 
-Coherence scale:
+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"""
+- 0.0-0.3: Not coherent, no clear logical relationship
+
+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."""
 
         conversation = ConversationFacilitator()
         return await conversation.submit(
@@ -238,10 +296,15 @@ Coherence scale:
         score_2 = result.a_plus_without_t_plus_yields_a_minus_score
         avg_score = (score_1 + score_2) / 2
 
+        dv_1 = result.t_plus_without_a_plus_yields_t_minus_dv
+        dv_2 = result.a_plus_without_t_plus_yields_a_minus_dv
+        avg_dv = (dv_1 + dv_2) / 2
+
         self._report.artifacts["t_plus_without_a_plus_yields_t_minus"] = score_1
         self._report.artifacts["a_plus_without_t_plus_yields_a_minus"] = score_2
         self._report.artifacts["average"] = avg_score
         self._report.artifacts["is_coherent"] = result.is_coherent
+        self._report.artifacts["dialectical_validity"] = avg_dv
 
         self._report.ok = True
         status = "COHERENT" if result.is_coherent else "NOT COHERENT"
@@ -249,5 +312,5 @@ Coherence scale:
             f"Control Statements Check: {status} "
             f"(T+\\A+→T-={score_1:.2f}, "
             f"A+\\T+→A-={score_2:.2f}, "
-            f"avg={avg_score:.2f})"
+            f"avg={avg_score:.2f}, DV={avg_dv:.2f})"
         )