dialectical-framework 1.5.4__tar.gz → 1.5.6__tar.gz

{dialectical_framework-1.5.4 → dialectical_framework-1.5.6}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dialectical-framework"
-version = "1.5.4"
+version = "1.5.6"
 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.5.4 → dialectical_framework-1.5.6}/src/dialectical_framework/agents/analyst/skills/expand_polarities.py

@@ -18,27 +18,36 @@ from pydantic import Field
 
 from dialectical_framework.agents.reasonable_concern import ReasonableConcern
 from dialectical_framework.enums.di import DI
-from dialectical_framework.concerns.aspect_generation import (AspectGeneration,
-                                                              AspectResult)
-from dialectical_framework.concerns.statement_deduplication import \
-    StatementDeduplication
+from dialectical_framework.concerns.aspect_generation import (
+    AspectGeneration,
+    AspectResult,
+)
+from dialectical_framework.concerns.statement_deduplication import (
+    StatementDeduplication,
+)
 from dialectical_framework.graph.nodes.polarity import Polarity
-from dialectical_framework.graph.nodes.perspective import (POSITION_A_MINUS,
-                                                           POSITION_A_PLUS,
-                                                           POSITION_T_MINUS,
-                                                           POSITION_T_PLUS,
-                                                           Perspective)
+from dialectical_framework.graph.nodes.perspective import (
+    POSITION_A_MINUS,
+    POSITION_A_PLUS,
+    POSITION_T_MINUS,
+    POSITION_T_PLUS,
+    Perspective,
+)
 from dialectical_framework.graph.relationships.polarity_relationship import (
-    AMinusRelationship, APlusRelationship, HasPolarityRelationship,
-    TMinusRelationship, TPlusRelationship)
-from dialectical_framework.graph.repositories.statement_repository import \
-    StatementRepository
-from dialectical_framework.graph.repositories.input_repository import \
-    InputRepository
-from dialectical_framework.graph.repositories.node_repository import \
-    NodeRepository
-from dialectical_framework.graph.repositories.perspective_repository import \
-    PerspectiveRepository
+    AMinusRelationship,
+    APlusRelationship,
+    HasPolarityRelationship,
+    TMinusRelationship,
+    TPlusRelationship,
+)
+from dialectical_framework.graph.repositories.statement_repository import (
+    StatementRepository,
+)
+from dialectical_framework.graph.repositories.input_repository import InputRepository
+from dialectical_framework.graph.repositories.node_repository import NodeRepository
+from dialectical_framework.graph.repositories.perspective_repository import (
+    PerspectiveRepository,
+)
 
 if TYPE_CHECKING:
     from dialectical_framework.protocols.input_resolver import InputResolver
@@ -51,20 +60,22 @@ class ExpandPolarity(ReasonableConcern[list[Perspective]]):
     Creates Perspectives from a Polarity by generating and connecting aspects
     (T+, T-, A+, A-).
 
-    Each call produces one NEW perspective (alternative tetrad) for the Polarity,
-    using `not_like_these` to ensure diversity from existing ones. Call multiple
-    times on the same Polarity to build a richer space of tetrads.
+    Each call produces `count` NEW perspectives (alternative tetrads) for the
+    Polarity, generated sequentially so each uses `not_like_these` (existing +
+    already-generated-this-call) to ensure diversity. Any pre-existing partial
+    Perspective counts toward `count`.
 
     Flow:
     1. Resolve Polarity by hash
     2. Look up existing Perspectives for this Polarity
-    3. If none exist, create a new Perspective
-    4. Complete all partial PPs by generating aspects
+    3. Create new partial Perspectives so `count` are generated this call
+    4. Complete all partial PPs sequentially by generating aspects
     5. Return list of completed Perspectives (existing + new)
     """
 
-    def __init__(self, polarity_hash: str) -> None:
+    def __init__(self, polarity_hash: str, count: int = 1) -> None:
         self.polarity_hash = polarity_hash
+        self.count = max(1, count)
 
     async def resolve(self) -> list[Perspective]:
         """
@@ -86,20 +97,17 @@ class ExpandPolarity(ReasonableConcern[list[Perspective]]):
         pp_repo = PerspectiveRepository()
         existing_pps = pp_repo.find_by_polarity(polarity)
 
-        if not existing_pps:
-            # No PP exists - create one referencing the Polarity
-            pp = self._create_perspective_for_polarity(polarity)
-            existing_pps = [pp]
-
         complete_pps = [pp for pp in existing_pps if pp.is_complete()]
         partial_pps = [pp for pp in existing_pps if not pp.is_complete()]
 
-        if not partial_pps:
-            # All existing perspectives are complete — create a new one
-            pp = self._create_perspective_for_polarity(polarity)
-            partial_pps = [pp]
+        # Complete any existing partials, then create additional new ones so that
+        # `count` fresh Perspectives are produced this call (a pre-existing partial
+        # counts as one of them).
+        additional_needed = self.count - len(partial_pps)
+        for _ in range(max(0, additional_needed)):
+            partial_pps.append(self._create_perspective_for_polarity(polarity))
 
-        # Complete all partial PPs
+        # Complete all partial PPs sequentially (each sees prior results)
         completed_pps: list[Perspective] = []
 
         for pp in partial_pps:
@@ -209,7 +217,12 @@ class ExpandPolarity(ReasonableConcern[list[Perspective]]):
 
     def _perspective_final_state(self, pp: Perspective) -> dict[str, str | None]:
         """Build a dict with the final post-dedup text at each position."""
-        positions = [POSITION_T_PLUS, POSITION_T_MINUS, POSITION_A_PLUS, POSITION_A_MINUS]
+        positions = [
+            POSITION_T_PLUS,
+            POSITION_T_MINUS,
+            POSITION_A_PLUS,
+            POSITION_A_MINUS,
+        ]
         state: dict[str, str | None] = {"hash": pp.short_hash}
         for pos in positions:
             manager = pp.get_relationship_manager_by_position(pos)
@@ -299,13 +312,22 @@ class ExpandPolarity(ReasonableConcern[list[Perspective]]):
 
 @llm.tool
 async def expand_polarities(
-    polarity_hashes: Annotated[list[str], Field(description="Hashes of Polarities to expand into full Perspectives")],
+    polarity_hashes: Annotated[
+        list[str],
+        Field(description="Hashes of Polarities to expand into full Perspectives"),
+    ],
+    count: Annotated[
+        int,
+        Field(
+            description="Number of new Perspectives to generate per Polarity (each is diverse from prior ones)"
+        ),
+    ] = 1,
 ) -> str:
-    """Build complete Perspectives from Polarities by generating evaluative aspects (T+, T-, A+, A-) for each. Each call generates one new Perspective per Polarity — call multiple times for alternative perspectives on the same Polarity (duplicates in a single call are ignored). The Polarities must already exist in the graph."""
+    """Build complete Perspectives from Polarities by generating evaluative aspects (T+, T-, A+, A-) for each. Generates `count` new Perspectives per Polarity sequentially — each sees prior tetrads to ensure diversity. The Polarities must already exist in the graph."""
     import asyncio
 
     async def _expand_one(h: str) -> str:
-        concern = ExpandPolarity(polarity_hash=h)
+        concern = ExpandPolarity(polarity_hash=h, count=count)
         await concern.resolve()
         return str(concern.report)
 

{dialectical_framework-1.5.4 → dialectical_framework-1.5.6}/src/dialectical_framework/agents/analyst/system_prompts.py

@@ -35,6 +35,13 @@ Choose your approach based on the user's input:
 - User is working step-by-step and asks for the next step
 - User refers to specific existing theses and wants tensions found
 - User explicitly asks to expand a polarity into perspectives
+- User asks to "find tetrades", "show aspects", "build T+/T-/A+/A-", or otherwise requests the four-aspect structure
+
+**Disambiguating "perspectives", "angles", "points of view":**
+These words map to DIFFERENT tools depending on what's in scope:
+- Polarity in view/referenced → `expand_polarities` (build the tetrad for that polarity)
+- Thesis in view/referenced → `find_polarities` (find opposing angles)
+- No specific node → check what exists: unexpanded polarities → `expand_polarities`; theses without polarities → `find_polarities`
 
 **Use `add_input` when:**
 - User provides multi-sentence source material (a paragraph, article, or detailed description) to capture before analysis
@@ -93,7 +100,7 @@ When the user wants to explore interactions between perspectives:
 - `surface_theses` — Extract theses from inputs (requires inputs in scope).
 - `find_polarities` — Find antitheses for existing theses.
 - `introduce_polarity` — Directly introduce a known T-A tension (both sides clear).
-- `expand_polarities` — Expand polarities into full Perspectives (T+/T-/A+/A-).
+- `expand_polarities` — Expand polarities into full Perspectives (T+/T-/A+/A-). Pass `count > 1` to generate several diverse tetrads per polarity in one call.
 - `place_statement` — Check if a statement exists in the graph already.
 
 **Steering:**

{dialectical_framework-1.5.4 → dialectical_framework-1.5.6}/src/dialectical_framework/agents/apps.py

@@ -341,8 +341,11 @@ both sides contribute", "constructive co-existence", "where 1+1 > 2".
 
 ## Viewport Scope
 
-Messages may include context about what the user is currently viewing. This tells you their active focus. Respect it:
+Messages may begin with `[User is currently viewing: ...]`. This tells you their active focus — use it to resolve ambiguous requests:
 
+- When the user asks for an action without specifying a target (e.g., "find tetrades", "expand", "show aspects", "find perspectives"), apply it to the node in their current view.
+- If a polarity is in view and the user asks for tetrades/aspects/perspectives/angles, expand that polarity into its full structure.
+- If a thesis is in view and the user asks for perspectives/angles/oppositions, find opposing viewpoints for that thesis.
 - Only operate on the node(s) in the user's viewport unless they explicitly reference something else or ask to switch.
 - Never silently pivot to other nodes outside the viewport. If you think working on a different node would help, ask first.
 
@@ -487,5 +490,5 @@ rules. Adjust interaction accordingly:
 - Present tetrads structurally with all six positions and scores.
 - Show transformation positions explicitly: Ac, Ac+, Ac-, Re, Re+, Re-.
 - Show control statements, modality alignment, diagonal contradictions.
-- Suggest next steps but don't auto-execute — the user drives.
+- Suggest exploration-phase next steps (nexus, wheels) rather than auto-executing — the user drives structural expansion. Analysis tools (expand, find) still follow "act on clear intent."
 """

{dialectical_framework-1.5.4 → dialectical_framework-1.5.6}/src/dialectical_framework/concerns/create_nexus.py

@@ -10,8 +10,7 @@ from typing import Optional
 from dialectical_framework.agents.reasonable_concern import ReasonableConcern
 from dialectical_framework.graph.nodes.nexus import Nexus
 from dialectical_framework.graph.nodes.perspective import Perspective
-from dialectical_framework.graph.repositories.node_repository import \
-    NodeRepository
+from dialectical_framework.graph.repositories.node_repository import NodeRepository
 from dialectical_framework.protocols.has_config import SettingsAware
 
 
@@ -48,7 +47,16 @@ class CreateNexus(SettingsAware, ReasonableConcern[CreateNexusResult]):
 
         repo = NodeRepository()
         perspectives: list[Perspective] = []
+        # Dedup input hashes, preserving order: BELONGS_TO_NEXUS is a directed
+        # relationship, so connect() does NOT deduplicate. A repeated hash here
+        # would create duplicate edges, causing nexus.perspectives.all() to
+        # yield the same PP twice and poisoning combination generation
+        # (degenerate cycles with repeated perspective_hashes).
+        seen_hashes: set[str] = set()
         for pp_hash in perspective_hashes:
+            if pp_hash in seen_hashes:
+                continue
+            seen_hashes.add(pp_hash)
             node = repo.find_by_hash(pp_hash, node_type=Perspective)
             if node is None:
                 raise ValueError(f"Perspective not found: {pp_hash}")

{dialectical_framework-1.5.4 → dialectical_framework-1.5.6}/src/dialectical_framework/concerns/perspective_combination.py

@@ -43,7 +43,6 @@ from dialectical_framework.graph.repositories.wheel_repository import WheelRepos
 from dialectical_framework.protocols.has_config import SettingsAware
 from dialectical_framework.utils.sequence_generation import (
     generate_compatible_sequences,
-    generate_permutation_sequences,
 )
 
 if TYPE_CHECKING:
@@ -123,26 +122,37 @@ class PerspectiveCombination(ReasonableConcern[CombinationResult], SettingsAware
             self._report.ok = False
             self._report.summary = "Nexus must be committed before combination"
             return CombinationResult(
-                nexus=nexus, cycles=[], wheels=[],
-                cycles_by_layer={}, wheels_by_layer={},
+                nexus=nexus,
+                cycles=[],
+                wheels=[],
+                cycles_by_layer={},
+                wheels_by_layer={},
             )
 
         if not perspectives:
             self._report.ok = False
             self._report.summary = "No Perspectives provided"
             return CombinationResult(
-                nexus=nexus, cycles=[], wheels=[],
-                cycles_by_layer={}, wheels_by_layer={},
+                nexus=nexus,
+                cycles=[],
+                wheels=[],
+                cycles_by_layer={},
+                wheels_by_layer={},
             )
 
         # Validate all PPs are committed
         for pp in perspectives:
             if not pp.is_committed:
                 self._report.ok = False
-                self._report.summary = "Perspective must be committed before combination"
+                self._report.summary = (
+                    "Perspective must be committed before combination"
+                )
                 return CombinationResult(
-                    nexus=nexus, cycles=[], wheels=[],
-                    cycles_by_layer={}, wheels_by_layer={},
+                    nexus=nexus,
+                    cycles=[],
+                    wheels=[],
+                    cycles_by_layer={},
+                    wheels_by_layer={},
                 )
 
         # Add PPs to Nexus (idempotent — skip already connected)
@@ -151,8 +161,19 @@ class PerspectiveCombination(ReasonableConcern[CombinationResult], SettingsAware
         self._report.artifacts["nexus_hash"] = nexus.short_hash
         self._report.artifacts["perspective_count"] = len(perspectives)
 
-        # Build from all PPs in Nexus (not just the ones passed in)
-        all_nexus_pps = [pp for pp, _ in nexus.perspectives.all()]
+        # Build from all PPs in Nexus (not just the ones passed in).
+        # Dedup by hash, preserving order: nexus.perspectives.all() can yield
+        # the same Perspective twice if a duplicate BELONGS_TO_NEXUS edge exists
+        # (BELONGS_TO_NEXUS is a directed relationship — connect() does NOT
+        # deduplicate it). combinations() over a list with repeats produces
+        # degenerate cycles whose perspective_hashes repeat a PP, corrupting
+        # all downstream wheel rendering.
+        seen: set[str] = set()
+        all_nexus_pps = [
+            pp
+            for pp, _ in nexus.perspectives.all()
+            if pp.hash not in seen and not seen.add(pp.hash)
+        ]
         total_pps = len(all_nexus_pps)
 
         # Build combinations layer by layer, collect only new structures
@@ -265,8 +286,8 @@ class PerspectiveCombination(ReasonableConcern[CombinationResult], SettingsAware
         """
         Generate T-cycle permutations for a PP combination.
 
-        Uses generate_permutation_sequences to produce all (N-1)! unique
-        T-cycle orderings (first element fixed to eliminate rotational duplicates).
+        Fixes the first perspective and permutes the rest to produce all
+        (N-1)! unique cycle orderings (circular rotation equivalence eliminated).
 
         Returns:
             Tuple of (all_cycles, new_cycles)
@@ -282,26 +303,17 @@ class PerspectiveCombination(ReasonableConcern[CombinationResult], SettingsAware
                 new_cycles.append(cycle)
             return all_cycles, new_cycles
 
-        # Extract T components and build component→PP lookup
-        t_components: list[Statement] = []
-        comp_hash_to_pp: dict[str, Perspective] = {}
+        # Validate all PPs have T components
         for pp in perspectives:
-            t_result = pp.t.get()
-            if not t_result:
-                continue
-            t_comp = t_result[0]
-            t_components.append(t_comp)
-            comp_hash_to_pp[t_comp.hash] = pp
+            if not pp.t.get():
+                return all_cycles, new_cycles
 
-        if not t_components:
-            return all_cycles, new_cycles
+        # Generate all (N-1)! orderings by fixing first PP, permuting rest
+        from itertools import permutations as itertools_permutations
 
-        # Generate all (N-1)! permutation sequences
-        sequences = generate_permutation_sequences(t_components)
-
-        for sequence in sequences:
-            # Map component sequence back to PP ordering
-            ordered_pps = [comp_hash_to_pp[comp.hash] for comp in sequence]
+        first, rest = perspectives[0], perspectives[1:]
+        for perm in itertools_permutations(rest):
+            ordered_pps = [first, *perm]
 
             cycle, is_new = self._find_or_create_cycle(ordered_pps)
             all_cycles.append(cycle)
@@ -324,13 +336,17 @@ class PerspectiveCombination(ReasonableConcern[CombinationResult], SettingsAware
         Returns:
             Tuple of (Cycle, is_new)
         """
-        from dialectical_framework.graph.repositories.cycle_repository import CycleRepository
+        from dialectical_framework.graph.repositories.cycle_repository import (
+            CycleRepository,
+        )
 
         # Layer-1 (single PP) Cycles have no causality intent (nothing to order)
         intent = self._preset if len(perspectives) >= 2 else None
 
         cycle_repo = CycleRepository()
-        existing_cycles = cycle_repo.find_by_perspectives(perspectives, exact_order=True)
+        existing_cycles = cycle_repo.find_by_perspectives(
+            perspectives, exact_order=True
+        )
 
         for cycle in existing_cycles:
             if cycle.intent == intent:
@@ -402,9 +418,7 @@ class PerspectiveCombination(ReasonableConcern[CombinationResult], SettingsAware
                 transition.commit()
                 transition.cycle.connect(wheel)
                 self._report.node_created(transition)
-                self._report.relationship_created(
-                    transition.cycle, transition, wheel
-                )
+                self._report.relationship_created(transition.cycle, transition, wheel)
 
             # Connect to cycle
             cycle.wheels.connect(wheel)
@@ -432,7 +446,9 @@ class PerspectiveCombination(ReasonableConcern[CombinationResult], SettingsAware
         Two sequences are opposite-direction if one is a circular reverse of the other.
         Connects pairs via the OPPOSITE_DIRECTION symmetric relationship.
         """
-        from dialectical_framework.graph.repositories.cycle_repository import CycleRepository
+        from dialectical_framework.graph.repositories.cycle_repository import (
+            CycleRepository,
+        )
 
         cycle_repo = CycleRepository()
         wheel_repo = WheelRepository()
@@ -461,7 +477,7 @@ def _connect_opposite_direction_cycles(
 
     for i, cycle_a in enumerate(cycles):
         seq_a = cycle_a.perspective_hashes
-        for cycle_b in cycles[i + 1:]:
+        for cycle_b in cycles[i + 1 :]:
             seq_b = cycle_b.perspective_hashes
             if _is_circular_reverse(seq_a, seq_b):
                 pair_id = tuple(sorted([cycle_a.hash, cycle_b.hash]))
@@ -486,7 +502,7 @@ def _connect_opposite_direction_wheels(
         wheel_sequences.append((wheel, comp_hashes))
 
     for i, (wheel_a, seq_a) in enumerate(wheel_sequences):
-        for wheel_b, seq_b in wheel_sequences[i + 1:]:
+        for wheel_b, seq_b in wheel_sequences[i + 1 :]:
             if _is_circular_reverse(seq_a, seq_b):
                 pair_id = tuple(sorted([wheel_a.hash, wheel_b.hash]))
                 if pair_id not in connected:
@@ -508,7 +524,4 @@ def _is_circular_reverse(seq_a: list[str], seq_b: list[str]) -> bool:
     if len(seq_a) <= 2:
         return False
     reversed_a = list(reversed(seq_a))
-    return any(
-        reversed_a[i:] + reversed_a[:i] == seq_b
-        for i in range(len(reversed_a))
-    )
+    return any(reversed_a[i:] + reversed_a[:i] == seq_b for i in range(len(reversed_a)))

{dialectical_framework-1.5.4 → dialectical_framework-1.5.6}/src/dialectical_framework/graph/nodes/cycle.py

@@ -14,7 +14,11 @@ from typing import ClassVar, Optional, TYPE_CHECKING
 
 from dialectical_framework.graph.nodes.assessable_entity import AssessableEntity
 from dialectical_framework.graph.mixins.intent_mixin import IntentMixin
-from dialectical_framework.graph.relationship_manager import RelationshipTo, RelationshipBoth, RelationshipManager
+from dialectical_framework.graph.relationship_manager import (
+    RelationshipTo,
+    RelationshipBoth,
+    RelationshipManager,
+)
 from dialectical_framework.graph.relationships.has_wheel_relationship import (
     HasWheelRelationship,
 )
@@ -82,7 +86,7 @@ class Cycle(IntentMixin, AssessableEntity, label="Cycle"):
     wheels: ClassVar[RelationshipManager[Wheel]] = RelationshipTo(
         "Wheel",
         model=HasWheelRelationship,
-        cardinality=(0, None)  # Zero or more wheels can implement this cycle
+        cardinality=(0, None),  # Zero or more wheels can implement this cycle
     )
 
     # Opposite-direction counterpart (symmetric)
@@ -100,22 +104,31 @@ class Cycle(IntentMixin, AssessableEntity, label="Cycle"):
         Order determines the T-cycle: T1 → T2 → T3 → T1...
 
         Args:
-            perspectives: Ordered list of committed Perspectives
+            perspectives: Ordered list of committed, distinct Perspectives
 
         Returns:
             Self for chaining
 
         Raises:
-            ValueError: If any PP is not committed
+            ValueError: If any PP is not committed, or if any PP is repeated
         """
         hashes = []
         for pp in perspectives:
             if not pp.is_committed:
-                raise ValueError(
-                    "Perspective must be committed before adding to Cycle"
-                )
+                raise ValueError("Perspective must be committed before adding to Cycle")
             hashes.append(pp.hash)
 
+        # Reject duplicate perspectives. A cycle claiming to be "layer N"
+        # (N = len(perspective_hashes)) must reference N *distinct* PPs.
+        # Duplicates produce degenerate cycles (e.g. combinations() over a
+        # PP list poisoned by a transient duplicate BELONGS_TO_NEXUS edge)
+        # that render as malformed wheels. Fail loud so corruption is never
+        # persisted rather than surfacing later in the consuming app.
+        if len(set(hashes)) != len(hashes):
+            raise ValueError(
+                f"Cycle perspectives must be distinct; got duplicates in {hashes}"
+            )
+
         self.perspective_hashes = hashes
         self._pp_refs = perspectives  # Keep refs for potential use
         return self
@@ -133,7 +146,10 @@ class Cycle(IntentMixin, AssessableEntity, label="Cycle"):
         if not self.perspective_hashes:
             return []
 
-        from dialectical_framework.graph.repositories.node_repository import NodeRepository
+        from dialectical_framework.graph.repositories.node_repository import (
+            NodeRepository,
+        )
+
         repo = NodeRepository()
 
         result = []
@@ -268,4 +284,3 @@ class Cycle(IntentMixin, AssessableEntity, label="Cycle"):
         hash_str = self.short_hash if self.is_committed else "uncommitted"
         pp_count = len(self.perspective_hashes)
         return f"Cycle({hash_str}, pp_count={pp_count}, intent={self.intent})"
-