dialectical-framework 1.2.0__tar.gz → 1.2.2__tar.gz

{dialectical_framework-1.2.0 → dialectical_framework-1.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dialectical-framework
-Version: 1.2.0
+Version: 1.2.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

{dialectical_framework-1.2.0 → dialectical_framework-1.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dialectical-framework"
-version = "1.2.0"
+version = "1.2.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"

{dialectical_framework-1.2.0 → dialectical_framework-1.2.2}/src/dialectical_framework/agents/analyst/skills/anchor_theses.py

@@ -135,6 +135,7 @@ class AnchorTheses(ReasonableConcern[Optional[Ideas]]):
         intent = ", ".join(self.statements)
         ideas = Ideas(intent=intent)
         ideas.save()
+        self._report.node_created(ideas)
 
         for input_node in self._get_inputs():
             ideas.inputs.connect(input_node)
@@ -145,7 +146,7 @@ class AnchorTheses(ReasonableConcern[Optional[Ideas]]):
             self._report.relationship_created(ideas.statements, ideas, comp)
 
         ideas.commit()
-        self._report.node_created(ideas)
+        self._report.node_committed(ideas)
 
         return ideas
 

{dialectical_framework-1.2.0 → dialectical_framework-1.2.2}/src/dialectical_framework/agents/analyst/skills/edit_perspective.py

@@ -129,10 +129,12 @@ class EditPerspective(ReasonableConcern[EditPerspectiveResult]):
         if self._was_committed:
             working_pp = pp.clone()
             working_pp.save()
+            self._report.node_created(working_pp)
         else:
             working_pp = pp
             if not working_pp._id:
                 working_pp.save()
+                self._report.node_created(working_pp)
         self._working_pp = working_pp
 
         # Route based on what's changing
@@ -401,7 +403,7 @@ class EditPerspective(ReasonableConcern[EditPerspectiveResult]):
             )
 
         pp.commit()
-        self._report.node_created(pp)
+        self._report.node_committed(pp)
 
     # ─── Tetrad editing (aspect changes only → validate coherence) ───
 
@@ -469,7 +471,7 @@ class EditPerspective(ReasonableConcern[EditPerspectiveResult]):
             )
 
         self._working_pp.commit()
-        self._report.node_created(self._working_pp)
+        self._report.node_committed(self._working_pp)
 
         return EditPerspectiveResult(
             perspective=self._working_pp,

{dialectical_framework-1.2.0 → dialectical_framework-1.2.2}/src/dialectical_framework/agents/analyst/skills/expand_polarities.py

@@ -129,7 +129,7 @@ class ExpandPolarity(ReasonableConcern[list[Perspective]]):
                 continue
 
             pp.commit()
-            self._report.node_created(pp)
+            self._report.node_committed(pp)
             completed_pps.append(pp)
 
         # Return all PPs: existing complete + newly completed

{dialectical_framework-1.2.0 → dialectical_framework-1.2.2}/src/dialectical_framework/agents/analyst/skills/find_polarities.py

@@ -503,6 +503,7 @@ class FindPolarities(ReasonableConcern[Optional[Ideas]]):
 
         ideas = Ideas(intent=intent)
         ideas.save()
+        self._report.node_created(ideas)
 
         # Connect to inputs
         input_repo = InputRepository()
@@ -531,7 +532,7 @@ class FindPolarities(ReasonableConcern[Optional[Ideas]]):
                     )
 
         ideas.commit()
-        self._report.node_created(ideas)
+        self._report.node_committed(ideas)
 
         # Add rationale
         total_theses = len(valid_results)

{dialectical_framework-1.2.0 → dialectical_framework-1.2.2}/src/dialectical_framework/agents/analyst/skills/surface_theses.py

@@ -387,6 +387,7 @@ Determine:
 
         ideas = Ideas(intent=self.intent)
         ideas.save()
+        self._report.node_created(ideas)
 
         # Connect to inputs (filtered or all)
         for input_node in self._get_inputs():
@@ -399,7 +400,7 @@ Determine:
             self._report.relationship_created(ideas.statements, ideas, comp)
 
         ideas.commit()
-        self._report.node_created(ideas)
+        self._report.node_committed(ideas)
 
         # Attach rationale explaining how intent was interpreted
         if parsed.reasoning:

{dialectical_framework-1.2.0 → dialectical_framework-1.2.2}/src/dialectical_framework/agents/execution_report.py

@@ -73,6 +73,7 @@ def _resolve_rel_type(rel_type: RelType) -> str:
 
 EffectType = Literal[
     "node_created",
+    "node_committed",
     "node_updated",
     "node_deleted",
     "relationship_created",
@@ -93,10 +94,15 @@ class NodeRef(BaseModel):
 
     label: str  # Node class name: "Statement", "Perspective", etc.
     hash: Optional[str] = None  # 7-char short hash (None if uncommitted/draft)
+    db_id: Optional[int] = None  # DB internal ID (available after save)
 
     @classmethod
     def from_node(cls, node: BaseNode) -> NodeRef:
-        return cls(label=node.__class__.__name__, hash=node.short_hash)
+        return cls(
+            label=node.__class__.__name__,
+            hash=node.short_hash,
+            db_id=node._id,
+        )
 
 
 class RelationshipRef(BaseModel):
@@ -269,6 +275,27 @@ class ExecutionReport(BaseModel):
         self._emit(effect)
         self._log(effect)
 
+    def node_committed(
+        self,
+        node: BaseNode,
+        patch: Optional[dict[str, Any]] = None,
+        meta: Optional[dict[str, Any]] = None,
+    ) -> None:
+        """Record that a draft node was committed (hash now available)."""
+        default_patch = {"text": getattr(node, "text", None)}
+        if patch:
+            default_patch.update(patch)
+        effect = Effect(
+            seq=self._next_seq(),
+            effect_type="node_committed",
+            node=NodeRef.from_node(node),
+            patch=default_patch,
+            meta=meta or {},
+        )
+        self.effects.append(effect)
+        self._emit(effect)
+        self._log(effect)
+
     def node_updated(
         self,
         node: BaseNode,

{dialectical_framework-1.2.0 → dialectical_framework-1.2.2}/src/dialectical_framework/agents/explorer/explorer.py

@@ -9,6 +9,7 @@ Also contains ExplorationPipeline — the headless pipeline for programmatic use
 
 from __future__ import annotations
 
+import asyncio
 from typing import TYPE_CHECKING, Annotated, AsyncGenerator, Optional
 
 from mirascope import llm
@@ -230,21 +231,27 @@ class ExplorationPipeline(ReasonableConcern[ExplorationResult]):
 
         transformation_count = 0
 
-        for wheel_hash in wheel_hashes:
+        async def _explore_wheel(wheel_hash: str) -> tuple[int, Optional[StepError]]:
             try:
                 explore_tr = ExploreTransformations(wheel_hash=wheel_hash)
                 tr_result = await explore_tr.resolve()
                 reports.append(explore_tr.report)
-                transformation_count += len(tr_result.new)
+                return len(tr_result.new), None
             except Exception as e:
-                errors.append(
-                    StepError(
-                        step="explore_transformations",
-                        message=str(e),
-                        hash=wheel_hash,
-                    )
+                return 0, StepError(
+                    step="explore_transformations",
+                    message=str(e),
+                    hash=wheel_hash,
                 )
 
+        wheel_results = await asyncio.gather(*[
+            _explore_wheel(wh) for wh in wheel_hashes
+        ])
+        for count, error in wheel_results:
+            transformation_count += count
+            if error:
+                errors.append(error)
+
         self._report.ok = True
         self._report.summary = (
             f"Exploration complete: {len(cycle_hashes)} cycles, "

{dialectical_framework-1.2.0 → dialectical_framework-1.2.2}/src/dialectical_framework/agents/explorer/skills/explore_transformations.py

@@ -22,8 +22,10 @@ Usage:
 
 from __future__ import annotations
 
+import asyncio
+import logging
 from dataclasses import dataclass, field
-from typing import Annotated, Optional, TYPE_CHECKING
+from typing import Annotated, Any, Optional, TYPE_CHECKING
 
 from dependency_injector.wiring import Provide, inject
 from mirascope import llm
@@ -116,27 +118,47 @@ class ExploreTransformations(ReasonableConcern[ExploreTransformationsResult]):
         # 3. Get input text from scope
         input_text = await self._get_input_text()
 
-        # 4. Process each edge pair — both edges get Transformations
+        # 4. Process edge pairs in parallel — both edges get Transformations
+        pair_results = await asyncio.gather(
+            *[
+                self._process_edge_pair(wheel, nexus, edge_a, edge_b, input_text)
+                for edge_a, edge_b in edge_pairs
+            ],
+            return_exceptions=True,
+        )
+
         all_existing: list[Transformation] = []
         all_new: list[Transformation] = []
         last_apexes: Optional[ApexDerivationResultDto] = None
 
-        for edge_a, edge_b in edge_pairs:
-            existing, new, apexes = await self._process_edge_pair(
-                wheel, nexus, edge_a, edge_b, input_text
-            )
+        for result in pair_results:
+            if isinstance(result, Exception):
+                logging.getLogger(__name__).warning("Edge pair failed: %s", result)
+                continue
+            existing, new, apexes = result
             all_existing.extend(existing)
             all_new.extend(new)
             if apexes:
                 last_apexes = apexes
 
-        # 5. Audit new transformations for feasibility
+        # 5. Audit new transformations in parallel
         if all_new:
             from dialectical_framework.concerns.transformation_audit import TransformationAudit
-            for tr in all_new:
+
+            async def _audit_one(tr: Transformation) -> TransformationAudit:
                 auditor = TransformationAudit()
                 await auditor.resolve(tr, input_text)
-                self._report = self._report.merge(auditor.report)
+                return auditor
+
+            audit_results = await asyncio.gather(
+                *[_audit_one(tr) for tr in all_new],
+                return_exceptions=True,
+            )
+            for result in audit_results:
+                if isinstance(result, Exception):
+                    logging.getLogger(__name__).warning("Audit failed: %s", result)
+                    continue
+                self._report = self._report.merge(result.report)
 
         # Summary
         self._report.artifacts["wheel_hash"] = wheel.short_hash
@@ -166,8 +188,8 @@ class ExploreTransformations(ReasonableConcern[ExploreTransformationsResult]):
         """
         Process a diametrically opposite edge pair.
 
-        Phase 1: Extract Ac+ candidates for both edges independently.
-        Phase 2: Generate tetrads for each edge, passing the opposite Ac+ for Re-side.
+        Phase 1: Extract Ac+ candidates for both edges in parallel.
+        Phase 2: Generate tetrads for all candidates in parallel.
 
         Returns:
             Tuple of (existing, new, apexes)
@@ -176,11 +198,12 @@ class ExploreTransformations(ReasonableConcern[ExploreTransformationsResult]):
 
         tr_repo = TransformationRepository()
         all_existing: list[Transformation] = []
-        all_new: list[Transformation] = []
         last_apexes: Optional[ApexDerivationResultDto] = None
 
-        # Phase 1: Extract Ac+ for both edges (check existing first)
+        # Phase 1: Extract Ac+ for both edges in parallel (check existing first)
+        phase1_tasks: list[tuple[Transition, asyncio.Task]] = []
         edge_data: dict[str, _EdgeProcessingData] = {}
+
         for edge in (edge_a, edge_b):
             assert edge.hash is not None
             existing = tr_repo.find_by_edge(edge=edge)
@@ -198,43 +221,50 @@ class ExploreTransformations(ReasonableConcern[ExploreTransformationsResult]):
                 edge_data[edge.hash] = _EdgeProcessingData(skip=True)
                 continue
 
-            apex_service = ApexDerivation()
-            apexes = await apex_service.resolve(edge, input_text)
-            self._report = self._report.merge(apex_service.report)
-            last_apexes = apexes
-
-            extractor = ActionExtraction()
-            ac_candidates = await extractor.resolve(
-                edge, input_text,
-                not_like_these=wheel.transformations,
-            )
-            self._report = self._report.merge(extractor.report)
-
             edge_data[edge.hash] = _EdgeProcessingData(
-                ac_candidates=ac_candidates or [],
-                apexes=apexes,
                 source_segment=source_segment,
                 target_segment=target_segment,
             )
+            phase1_tasks.append((edge, asyncio.ensure_future(
+                self._phase1_for_edge(edge, wheel, input_text)
+            )))
+
+        # Await Phase 1 tasks in parallel
+        if phase1_tasks:
+            results = await asyncio.gather(
+                *[t for _, t in phase1_tasks],
+                return_exceptions=True,
+            )
+            for (edge, _), result in zip(phase1_tasks, results):
+                assert edge.hash is not None
+                if isinstance(result, Exception):
+                    logging.getLogger(__name__).warning(
+                        "Phase 1 failed for edge %s: %s", edge.short_hash, result
+                    )
+                    edge_data[edge.hash] = _EdgeProcessingData(skip=True)
+                    continue
+                apexes, ac_candidates, report = result
+                self._report = self._report.merge(report)
+                if apexes:
+                    last_apexes = apexes
+                data = edge_data[edge.hash]
+                data.apexes = apexes
+                data.ac_candidates = ac_candidates or []
+
+        # Phase 2: Generate tetrads in parallel
+        generation_tasks: list[tuple[Transition, _EdgeProcessingData, ActionCandidateResultDto, asyncio.Task]] = []
 
-        # Phase 2: Generate tetrads using opposite Ac+ for Re-side
         for edge, opposite_edge in [(edge_a, edge_b), (edge_b, edge_a)]:
             assert edge.hash is not None
             assert opposite_edge.hash is not None
             data = edge_data.get(edge.hash)
             if not data or data.existing or data.skip:
                 continue
-
             if not data.ac_candidates:
                 continue
-
-            source_segment = data.source_segment
-            target_segment = data.target_segment
-            apexes = data.apexes
-            if not source_segment or not target_segment or not apexes:
+            if not data.source_segment or not data.target_segment or not data.apexes:
                 continue
 
-            # Get opposite edge's Ac+ candidates for Re-side context
             opp_data = edge_data.get(opposite_edge.hash)
             opp_ac_candidates = opp_data.ac_candidates if opp_data else []
 
@@ -245,19 +275,72 @@ class ExploreTransformations(ReasonableConcern[ExploreTransformationsResult]):
                 if not opposite_ac:
                     continue
 
-                generator = TransformationGeneration()
-                tetrad = await generator.resolve(
-                    edge, ac_plus, opposite_ac, apexes, input_text
+                task = asyncio.ensure_future(
+                    self._generate_tetrad(edge, ac_plus, opposite_ac, data.apexes, input_text)
                 )
-                self._report = self._report.merge(generator.report)
+                generation_tasks.append((edge, data, ac_plus, task))
 
+        # Await all generation tasks and create graph nodes sequentially
+        all_new: list[Transformation] = []
+        if generation_tasks:
+            tetrad_results = await asyncio.gather(
+                *[t for _, _, _, t in generation_tasks],
+                return_exceptions=True,
+            )
+            for (edge, data, _, _), result in zip(generation_tasks, tetrad_results):
+                if isinstance(result, Exception):
+                    logging.getLogger(__name__).warning(
+                        "Tetrad generation failed for edge %s: %s", edge.short_hash, result
+                    )
+                    continue
+                tetrad, report = result
+                self._report = self._report.merge(report)
+                assert data.source_segment is not None
+                assert data.target_segment is not None
                 transformation = self._create_transformation(
-                    nexus, edge, source_segment, target_segment, tetrad,
+                    nexus, edge, data.source_segment, data.target_segment, tetrad,
                 )
                 all_new.append(transformation)
 
         return all_existing, all_new, last_apexes
 
+    async def _phase1_for_edge(
+        self,
+        edge: Transition,
+        wheel: Wheel,
+        input_text: str,
+    ) -> tuple[Optional[ApexDerivationResultDto], list[ActionCandidateResultDto], Any]:
+        """Run ApexDerivation + ActionExtraction for a single edge. Returns (apexes, candidates, merged_report)."""
+        from dialectical_framework.agents.execution_report import ExecutionReport
+
+        merged_report = ExecutionReport(tool=self.__class__.__name__)
+
+        apex_service = ApexDerivation()
+        apexes = await apex_service.resolve(edge, input_text)
+        merged_report = merged_report.merge(apex_service.report)
+
+        extractor = ActionExtraction()
+        ac_candidates = await extractor.resolve(
+            edge, input_text,
+            not_like_these=wheel.transformations,
+        )
+        merged_report = merged_report.merge(extractor.report)
+
+        return apexes, ac_candidates or [], merged_report
+
+    async def _generate_tetrad(
+        self,
+        edge: Transition,
+        ac_plus: ActionCandidateResultDto,
+        opposite_ac: ActionCandidateResultDto,
+        apexes: ApexDerivationResultDto,
+        input_text: str,
+    ) -> tuple[TransformationTetradDto, Any]:
+        """Run TransformationGeneration for one candidate. Returns (tetrad, report)."""
+        generator = TransformationGeneration()
+        tetrad = await generator.resolve(edge, ac_plus, opposite_ac, apexes, input_text)
+        return tetrad, generator.report
+
     @staticmethod
     def _find_matching_category(
         candidates: list[ActionCandidateResultDto],
@@ -451,6 +534,7 @@ class ExploreTransformations(ReasonableConcern[ExploreTransformationsResult]):
         transformation.set_nexus(nexus)
         transformation.set_on_edge(ac_edge)
         transformation.save()
+        self._report.node_created(transformation)
 
         # === Ac-side (this edge's segments) ===
 
@@ -611,7 +695,7 @@ class ExploreTransformations(ReasonableConcern[ExploreTransformationsResult]):
 
         # Commit transformation
         transformation.commit()
-        self._report.node_created(transformation)
+        self._report.node_committed(transformation)
 
         return transformation
 

{dialectical_framework-1.2.0 → dialectical_framework-1.2.2}/src/dialectical_framework/agents/explorer/skills/generate_synthesis.py

@@ -109,6 +109,7 @@ class GenerateSynthesis(ReasonableConcern[GenerateSynthesisResult]):
         # Create Synthesis node and wire up
         synthesis = Synthesis()
         synthesis.save()
+        self._report.node_created(synthesis)
 
         synthesis.s_plus.connect(
             result.s_plus_statement,
@@ -126,7 +127,7 @@ class GenerateSynthesis(ReasonableConcern[GenerateSynthesisResult]):
         synthesis.commit()
 
         # Report
-        self._report.node_created(synthesis)
+        self._report.node_committed(synthesis)
         self._report.artifacts["wheel"] = wheel.short_hash
         self._report.artifacts["s_plus"] = result.s_plus_statement.text
         self._report.artifacts["s_minus"] = result.s_minus_statement.text

{dialectical_framework-1.2.0 → dialectical_framework-1.2.2}/src/dialectical_framework/agents/explorer/system_prompts.py

@@ -12,11 +12,10 @@ You are working within Nexus [{nexus_hash}]: "{nexus_intent}".
 ## Context
 
 A Nexus groups Perspectives (thesis-antithesis pairs with aspects T+/T-/A+/A-)
-for structural combination. Your job is to:
-1. Build the structural combinations (Cycles + Wheels) if not yet done.
-2. Generate Action-Reflection transformations for each Wheel.
-3. Help the user navigate the wisdom: what Ac+ and Re+ mean practically,
-   how S+ emerges, what pathways are available.
+for structural combination. Your job is to guide the user through three phases:
+1. **Navigation** — Build and present causal structures (Cycles + Wheels), helping the user understand which causality paths exist and which are most plausible.
+2. **Insight** — Generate transformations for wheels the user selects, revealing Ac+ and Re+ wisdom.
+3. **Synthesis** — Generate S+/S- for wheels that have transformations.
 
 ## How to Work
 
@@ -24,21 +23,32 @@ On first message (or when resuming):
 - Call `present_exploration` to see what's been built in this Nexus.
 - If wheels don't exist yet, call `build_wheels` to create them.
 - If build_wheels yields no wheels (e.g., only one position), explain that exploration needs at least two positions interacting — suggest the user adds more via the analysis thread.
-- If transformations don't exist yet, call `explore_transformations` for each wheel.
-- After transformations exist, call `generate_synthesis` to derive S+/S- for each wheel.
+
+After wheels exist — present the causality landscape:
+- Show which wheels exist and their causality scores (higher = more plausible).
+- Let the user choose which wheel(s) to explore further.
+- Do NOT automatically generate transformations for all wheels.
+
+When the user selects a wheel for deeper exploration:
+- Call `explore_transformations` for that specific wheel.
+- Then present the Ac+ and Re+ pathways that emerged.
+
+When the user wants synthesis:
+- Call `generate_synthesis` for a wheel that has transformations.
+- Do NOT generate synthesis for all wheels automatically.
 
 When presenting transformations:
 - Focus on the Ac+ (constructive action: T- -> A+) and Re+ (constructive reflection: A- -> T+).
-- These are the circular causality paths -- the non-obvious synthetic wisdom.
+- These are the circular causality paths — the non-obvious synthetic wisdom.
 - Explain what they mean practically for the user's situation.
 - Use the haiku and headline to make it memorable.
 
 When the user asks "what should I do?":
-- Draw from Ac+ paths -- these are concrete actions.
+- Draw from Ac+ paths — these are concrete actions.
 - Frame them as transitions from an exaggerated position to a constructive opposite.
 
 When the user asks "what should I reflect on?":
-- Draw from Re+ paths -- these are reflective shifts.
+- Draw from Re+ paths — these are reflective shifts.
 - Frame them as moving from underdevelopment to constructive balance.
 
 When the user wants to go deeper on a specific transformation:
@@ -47,13 +57,14 @@ When the user wants to go deeper on a specific transformation:
 
 ## Tools
 
-- `build_wheels` -- Generate causal structures (Cycles + Wheels) from this Nexus. Use nexus_hash: "{nexus_hash}".
-- `explore_transformations` -- Generate Action-Reflection transformations for a Wheel.
-- `generate_synthesis` -- Generate S+/S- synthesis for a Wheel. Requires transformations first.
-- `present_exploration` -- Show current state of this Nexus: perspectives, wheels, transformations.
-- `inspect_node` -- Deep-dive any node by hash.
-- `query_graph` -- Raw Cypher for custom queries. Call `get_schema` first.
-- `get_schema` -- Load graph schema on demand.
+- `build_wheels` — Generate causal structures (Cycles + Wheels) from this Nexus. Use nexus_hash: "{nexus_hash}".
+- `explore_transformations` — Generate Action-Reflection transformations for a specific Wheel the user chose.
+- `generate_synthesis` — Generate S+/S- synthesis for a Wheel. Requires transformations first.
+- `expand_nexus` — Add more Perspectives to this Nexus.
+- `present_exploration` — Show current state of this Nexus: perspectives, wheels, transformations.
+- `inspect_node` — Deep-dive any node by hash.
+- `query_graph` — Raw Cypher for custom queries. Call `get_schema` first.
+- `get_schema` — Load graph schema on demand.
 
 ## Response Style
 
@@ -66,4 +77,5 @@ Adapt depth and presentation to the persona defined in the app preamble.
 - When referencing structural nodes (Polarity, Perspective, Nexus, Cycle, Wheel, Transformation, Transition, Synthesis), always include the short hash for disambiguation.
 - If the user wants to analyze new material, suggest they return to the analysis thread.
 - Skill reports may contain truncated text previews. When you need to present exact node text to the user, use `inspect_node` or `present_analysis` by hash — never reconstruct or guess full text from truncated previews.
+- Do NOT eagerly explore all wheels or generate all syntheses. Let the user navigate and choose.
 """

{dialectical_framework-1.2.0 → dialectical_framework-1.2.2}/src/dialectical_framework/concerns/perspective_combination.py

@@ -387,6 +387,7 @@ class PerspectiveCombination(ReasonableConcern[CombinationResult]):
             # Create new wheel
             wheel = Wheel(intent=cycle.intent)
             wheel.save()
+            self._report.node_created(wheel)
 
             # Create transitions forming the circular causality sequence
             for i in range(len(components)):
@@ -407,7 +408,7 @@ class PerspectiveCombination(ReasonableConcern[CombinationResult]):
             cycle.wheels.connect(wheel)
 
             wheel.commit()
-            self._report.node_created(wheel)
+            self._report.node_committed(wheel)
             self._report.relationship_created(cycle.wheels, cycle, wheel)
 
             all_wheels.append(wheel)

dialectical_framework-1.2.2/src/dialectical_framework/utils/concurrency.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import asyncio
+import os
+from contextlib import asynccontextmanager
+from typing import AsyncIterator
+
+_semaphore: asyncio.Semaphore | None = None
+_disabled: bool | None = None
+
+
+def _init() -> None:
+    global _semaphore, _disabled
+    if _disabled is not None:
+        return
+    raw = os.environ.get("DIALEXITY_MAX_CONCURRENT_LLM_CALLS", "0")
+    try:
+        limit = int(raw)
+    except ValueError:
+        limit = 0
+    if limit > 0:
+        _semaphore = asyncio.Semaphore(limit)
+        _disabled = False
+    else:
+        _disabled = True
+
+
+@asynccontextmanager
+async def llm_concurrency_slot() -> AsyncIterator[None]:
+    """Acquire a concurrency slot for an LLM call. Disabled by default (no-op)."""
+    _init()
+    if _disabled:
+        yield
+    else:
+        assert _semaphore is not None
+        async with _semaphore:
+            yield