dialectical-framework 1.1.3__tar.gz → 1.2.1__tar.gz

{dialectical_framework-1.1.3 → dialectical_framework-1.2.1}/PKG-INFO

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

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

@@ -152,6 +152,7 @@ class ConversationFacilitator(SettingsAware):
 
         # Sync full conversation history from the response chain
         self._messages = list(response.messages)
+        self._strip_unsupported_input_fields()
 
         # Extract structured response
         return await self._call_with_response_model(response_model)
@@ -209,11 +210,30 @@ class ConversationFacilitator(SettingsAware):
             stream = await stream.resume(tool_outputs)
 
         self._messages = list(stream.messages)
+        self._strip_unsupported_input_fields()
         result = await self._call_with_response_model(response_model)
         yield ResponseComplete(result=result)
 
     # --- Internal helpers ---
 
+    def _strip_unsupported_input_fields(self) -> None:
+        """Strip output-only fields from raw_message before replaying to API.
+
+        Mirascope passes raw_message dicts back verbatim as input. If the API
+        added output-only fields (like 'caller' on tool_use blocks), they cause
+        400 errors on the next call. This strips them.
+        """
+        for msg in self._messages:
+            raw = getattr(msg, "raw_message", None)
+            if not isinstance(raw, dict):
+                continue
+            content = raw.get("content")
+            if not isinstance(content, list):
+                continue
+            for block in content:
+                if isinstance(block, dict) and block.get("type") == "tool_use":
+                    block.pop("caller", None)
+
     @staticmethod
     def _log_tool_calls(tool_calls: list) -> None:
         """Log tool invocations to the effect logger if configured."""

{dialectical_framework-1.1.3 → dialectical_framework-1.2.1}/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
@@ -121,6 +122,8 @@ def _build_tools() -> list:
         explore_transformations
     from dialectical_framework.agents.explorer.tools.expand_nexus import \
         expand_nexus
+    from dialectical_framework.agents.explorer.tools.generate_synthesis import \
+        generate_synthesis
     from dialectical_framework.agents.explorer.tools.present_exploration import \
         present_exploration
     from dialectical_framework.agents.orchestrator.tools.get_schema import \
@@ -133,6 +136,7 @@ def _build_tools() -> list:
     return [
         build_wheels,
         explore_transformations,
+        generate_synthesis,
         expand_nexus,
         present_exploration,
         inspect_node,
@@ -227,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.1.3 → dialectical_framework-1.2.1}/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],

dialectical_framework-1.2.1/src/dialectical_framework/agents/explorer/skills/generate_synthesis.py

@@ -0,0 +1,207 @@
+"""
+GenerateSynthesis: Skill for generating S+/S- synthesis from a Wheel.
+
+Orchestrates: resolve wheel → verify transformations → gather lower-layer
+context → call SynthesisGeneration concern → create Synthesis node → commit.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from itertools import combinations
+from typing import Optional, TYPE_CHECKING
+
+from dependency_injector.wiring import Provide, inject
+
+from dialectical_framework.agents.reasonable_concern import ReasonableConcern
+from dialectical_framework.concerns.synthesis_generation import (
+    SynthesisGeneration,
+    SynthesisResult,
+)
+from dialectical_framework.enums.di import DI
+from dialectical_framework.graph.nodes.statement import Statement
+from dialectical_framework.graph.nodes.synthesis import (
+    POSITION_S_MINUS,
+    POSITION_S_PLUS,
+    Synthesis,
+)
+from dialectical_framework.graph.relationships.polarity_relationship import (
+    SMinusRelationship,
+    SPlusRelationship,
+)
+from dialectical_framework.graph.relationships.synthesis_of_relationship import (
+    SynthesisOfRelationship,
+)
+
+if TYPE_CHECKING:
+    from dialectical_framework.graph.nodes.nexus import Nexus
+    from dialectical_framework.graph.nodes.perspective import Perspective
+    from dialectical_framework.graph.nodes.wheel import Wheel
+    from dialectical_framework.protocols.input_resolver import InputResolver
+
+
+@dataclass
+class GenerateSynthesisResult:
+    """Result from GenerateSynthesis skill."""
+
+    synthesis: Synthesis
+    is_new: bool = True
+
+
+class GenerateSynthesis(ReasonableConcern[GenerateSynthesisResult]):
+    """
+    Skill for generating S+/S- synthesis from a Wheel's Transformations.
+
+    Idempotent: returns existing Synthesis if one already exists for the Wheel.
+    """
+
+    def __init__(self, wheel_hash: str) -> None:
+        self.wheel_hash = wheel_hash
+
+    async def resolve(self) -> GenerateSynthesisResult:
+        """
+        Generate synthesis for a Wheel.
+
+        Returns:
+            GenerateSynthesisResult with the Synthesis node
+
+        Raises:
+            ValueError: If wheel not found or has no Transformations
+        """
+        wheel = self._resolve_wheel()
+
+        # Check transformations exist
+        transformations = wheel.transformations
+        if not transformations:
+            raise ValueError(
+                f"Wheel {wheel.short_hash} has no Transformations — "
+                f"run explore_transformations first"
+            )
+
+        # Idempotent: return existing synthesis
+        existing = self._find_existing_synthesis(wheel)
+        if existing:
+            self._report.summary = (
+                f"Synthesis already exists for Wheel {wheel.short_hash}"
+            )
+            self._report.artifacts["wheel"] = wheel.short_hash
+            self._report.artifacts["existing"] = True
+            return GenerateSynthesisResult(synthesis=existing, is_new=False)
+
+        # Gather context
+        input_text = await self._get_input_text()
+        lower_layer_context = self._build_lower_layer_context(wheel)
+
+        # Call the concern
+        concern = SynthesisGeneration()
+        result = await concern.resolve(
+            wheel=wheel,
+            input_text=input_text,
+            lower_layer_context=lower_layer_context,
+        )
+        self._report = self._report.merge(concern.report)
+
+        if result is None:
+            raise ValueError(
+                f"Synthesis generation failed for Wheel {wheel.short_hash}"
+            )
+
+        # Create Synthesis node and wire up
+        synthesis = Synthesis()
+        synthesis.save()
+
+        synthesis.s_plus.connect(
+            result.s_plus_statement,
+            relationship=SPlusRelationship(
+                alias=POSITION_S_PLUS, heuristic_similarity=None
+            ),
+        )
+        synthesis.s_minus.connect(
+            result.s_minus_statement,
+            relationship=SMinusRelationship(
+                alias=POSITION_S_MINUS, heuristic_similarity=None
+            ),
+        )
+        synthesis.target.connect(wheel, relationship=SynthesisOfRelationship())
+        synthesis.commit()
+
+        # Report
+        self._report.node_created(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
+        self._report.summary = (
+            f"Generated synthesis for Wheel {wheel.short_hash}: "
+            f"S+ = \"{result.s_plus_statement.text}\", "
+            f"S- = \"{result.s_minus_statement.text}\""
+        )
+
+        return GenerateSynthesisResult(synthesis=synthesis)
+
+    def _resolve_wheel(self) -> Wheel:
+        """Resolve Wheel from hash or prefix."""
+        from dialectical_framework.graph.nodes.wheel import Wheel
+        from dialectical_framework.graph.repositories.node_repository import (
+            NodeRepository,
+        )
+
+        repo = NodeRepository()
+        node = repo.find_by_hash(self.wheel_hash, node_type=Wheel)
+        if node is None:
+            raise ValueError(f"Wheel not found: {self.wheel_hash}")
+        return node
+
+    @staticmethod
+    def _find_existing_synthesis(wheel: Wheel) -> Optional[Synthesis]:
+        """Check if the wheel already has a synthesis."""
+        existing = list(wheel.synthesis.all())
+        if existing:
+            return existing[0][0]
+        return None
+
+    @inject
+    async def _get_input_text(
+        self,
+        input_resolver: InputResolver = Provide[DI.input_resolver],
+    ) -> str:
+        """Get concatenated text from all inputs in scope."""
+        from dialectical_framework.graph.repositories.input_repository import (
+            InputRepository,
+        )
+
+        repo = InputRepository()
+        inputs = repo.get_all()
+
+        if not inputs:
+            return ""
+
+        texts = []
+        for input_node in inputs:
+            resolved = await input_resolver.resolve(input_node)
+            texts.append(resolved)
+
+        return "\n\n---\n\n".join(texts)
+
+    def _build_lower_layer_context(self, wheel: Wheel) -> str:
+        """Find synthesis from sub-wheels (lower PP layers) sharing perspectives."""
+        from dialectical_framework.graph.repositories.wheel_repository import (
+            WheelRepository,
+        )
+
+        pps = wheel._perspectives
+        if len(pps) < 2:
+            return ""
+
+        wheel_repo = WheelRepository()
+        parts: list[str] = []
+
+        # Look one layer down (N-1 perspectives)
+        for combo in combinations(pps, len(pps) - 1):
+            sub_wheels = wheel_repo.find_by_layer(list(combo))
+            for sub_wheel in sub_wheels:
+                for synth, _ in sub_wheel.synthesis.all():
+                    parts.append(
+                        f"Sub-wheel [{sub_wheel.short_hash}]: {synth:positions:0}"
+                    )
+
+        return "\n".join(parts)

{dialectical_framework-1.1.3 → dialectical_framework-1.2.1}/src/dialectical_framework/agents/explorer/system_prompts.py

@@ -25,6 +25,7 @@ On first message (or when resuming):
 - 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.
 
 When presenting transformations:
 - Focus on the Ac+ (constructive action: T- -> A+) and Re+ (constructive reflection: A- -> T+).
@@ -48,6 +49,7 @@ When the user wants to go deeper on a specific transformation:
 
 - `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.

dialectical_framework-1.2.1/src/dialectical_framework/agents/explorer/tools/generate_synthesis.py

@@ -0,0 +1,27 @@
+"""
+generate_synthesis tool: thin LLM-facing wrapper around the GenerateSynthesis skill.
+"""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+from mirascope import llm
+from pydantic import Field
+
+from dialectical_framework.agents.explorer.skills.generate_synthesis import (
+    GenerateSynthesis,
+)
+
+
+@llm.tool
+async def generate_synthesis(
+    wheel_hash: Annotated[
+        str,
+        Field(description="Hash of the Wheel to generate synthesis for"),
+    ],
+) -> str:
+    """Generate S+/S- synthesis for a Wheel — the emergent properties arising from circular causality. S+ represents complementary harmony (1+1>2), S- represents reinforcing uniformity (1+1<2). The wheel must have transformations computed first."""
+    skill = GenerateSynthesis(wheel_hash=wheel_hash)
+    await skill.resolve()
+    return str(skill.report)

{dialectical_framework-1.1.3 → dialectical_framework-1.2.1}/src/dialectical_framework/agents/reasonable_concern.py

@@ -10,15 +10,40 @@ All three levels inherit from ReasonableConcern — same interface (resolve + re
 
 from __future__ import annotations
 
+import asyncio
+import inspect
 from abc import ABC, abstractmethod
+from functools import wraps
 from typing import TYPE_CHECKING, Any, Generic, TypeVar
 
+from langfuse import get_client, observe
+
 if TYPE_CHECKING:
     from dialectical_framework.agents.execution_report import ExecutionReport
 
 R_co = TypeVar("R_co", covariant=True)
 
 
+def _conditional_observe(name: str, fn: Any) -> Any:
+    """Wrap fn with @observe only when an active Langfuse trace exists."""
+    observed = observe(name=name)(fn)
+
+    if asyncio.iscoroutinefunction(fn):
+        @wraps(fn)
+        async def wrapper(*args: Any, **kwargs: Any) -> Any:
+            if get_client().get_current_trace_id():
+                return await observed(*args, **kwargs)
+            return await fn(*args, **kwargs)
+    else:
+        @wraps(fn)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            if get_client().get_current_trace_id():
+                return observed(*args, **kwargs)
+            return fn(*args, **kwargs)
+
+    return wrapper
+
+
 class ReasonableConcern(ABC, Generic[R_co]):
     """
     Base class for concerns, skills, and tools.
@@ -34,6 +59,12 @@ class ReasonableConcern(ABC, Generic[R_co]):
 
     _report: ExecutionReport
 
+    def __init_subclass__(cls, **kwargs: Any) -> None:
+        super().__init_subclass__(**kwargs)
+        if "resolve" in cls.__dict__:
+            original = cls.__dict__["resolve"]
+            cls.resolve = _conditional_observe(cls.__name__, original)  # type: ignore[assignment]
+
     def __getattr__(self, name: str) -> Any:
         if name == "_report":
             from dialectical_framework.agents.execution_report import ExecutionReport