dialectical-framework 1.6.1__tar.gz → 1.6.2__tar.gz

{dialectical_framework-1.6.1 → dialectical_framework-1.6.2}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dialectical-framework"
-version = "1.6.1"
+version = "1.6.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.6.1 → dialectical_framework-1.6.2}/src/dialectical_framework/agents/orchestrator/tools/inspect_node.py

@@ -431,6 +431,17 @@ def _inspect_wheel(wheel: Wheel) -> str:
     spiral_seq = format_spiral(wheel, pp_index)
     if spiral_seq:
         lines.append(f"Spiral: {spiral_seq}")
+
+    # Per-edge causation (rationales attached to edge Transitions)
+    edge_causations = []
+    for edge in wheel.edges:
+        for rationale, _ in edge.rationales.all():
+            if rationale.text:
+                label = format_edge_label(edge, pp_index)
+                edge_causations.append(f"  {label}: {rationale.text}")
+    if edge_causations:
+        lines.append("Step causation:")
+        lines.extend(edge_causations)
     lines.append("")
 
     # Parent cycle

{dialectical_framework-1.6.1 → dialectical_framework-1.6.2}/src/dialectical_framework/concerns/causality/causality_estimator.py

@@ -11,7 +11,7 @@ The CausalityEstimation concern handles normalization and database persistence.
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Union
 
 if TYPE_CHECKING:
@@ -19,6 +19,17 @@ if TYPE_CHECKING:
     from dialectical_framework.graph.nodes.wheel import Wheel
 
 
+@dataclass
+class StepCausation:
+    """Per-step causal justification within a sequence (aliases resolved)."""
+
+    source_hash: str
+    target_hash: str
+    source_text: str
+    target_text: str
+    causation: str  # Why source naturally leads to target
+
+
 @dataclass
 class EstimationStructured:
     """Raw AI estimation result for a single structure (Cycle or Wheel)."""
@@ -26,6 +37,7 @@ class EstimationStructured:
     probability: float  # Raw AI probability (0-1), NOT normalized
     reasoning: str  # Why this sequence might occur
     argumentation: str  # Circumstances where applicable
+    steps: list[StepCausation] = field(default_factory=list)  # Per-step causation
 
 
 class CausalityEstimator(ABC):

{dialectical_framework-1.6.1 → dialectical_framework-1.6.2}/src/dialectical_framework/concerns/causality/causality_estimator_balanced.py

@@ -17,6 +17,7 @@ from dialectical_framework.graph.nodes.wheel import Wheel
 from dialectical_framework.concerns.causality.causality_estimator import (
     CausalityEstimator,
     EstimationStructured,
+    StepCausation,
 )
 from dialectical_framework.protocols.input_resolver import InputResolver
 
@@ -24,7 +25,34 @@ from dialectical_framework.utils.dc_replace import dc_replace
 from dialectical_framework.utils.use_brain import use_brain
 
 
+class StepCausationDto(BaseModel):
+    from_alias: str = Field(
+        default="",
+        description="Technical alias of the step's source, exactly as given in the sequence (e.g. C1_1).",
+    )
+    to_alias: str = Field(
+        default="",
+        description="Technical alias of the step's target, exactly as given in the sequence (e.g. C1_2).",
+    )
+    causation: str = Field(
+        default="",
+        description=(
+            "One sentence: the causal mechanism why the source naturally leads to "
+            "the target. Use the actual statement wording, never aliases."
+        ),
+    )
+
+
 class CausalCycleAssessmentDto(BaseModel):
+    # steps comes FIRST: justifying each step before scoring is deliberate
+    # chain-of-thought — the holistic probability must be informed by them
+    steps: list[StepCausationDto] = Field(
+        default_factory=list,
+        description=(
+            "One entry per consecutive step of the sequence, in order, "
+            "including the final wrap-around step back to the first element."
+        ),
+    )
     probability: float = Field(
         default=0,
         description="The probability 0 to 1 of the arranged cycle to exist in reality.",
@@ -45,6 +73,61 @@ class CausalCycleDto(CausalCycleAssessmentDto):
     )
 
 
+def _resolve_steps(
+    step_dtos: list[StepCausationDto],
+    sequence: list[Statement],
+    seq_idx: int,
+    alias_translations: dict[str, str],
+) -> list[StepCausation]:
+    """
+    Resolve step DTOs (alias-identified) to StepCausation (hash/text-identified).
+
+    Primary path: parse C{seq}_{comp} aliases against the sequence.
+    Fallback: if aliases are garbled but the step count matches the sequence
+    length, map positionally (step i = statements[i] → statements[i+1 mod n]).
+    Otherwise drop the steps — per-step causation is best-effort enrichment.
+    """
+    n = len(sequence)
+    if not step_dtos or n == 0:
+        return []
+
+    def parse(alias: str) -> Optional[Statement]:
+        parts = alias.strip().split("_")
+        if len(parts) != 2 or not parts[0].startswith("C"):
+            return None
+        try:
+            s, c = int(parts[0][1:]), int(parts[1])
+        except ValueError:
+            return None
+        if s != seq_idx or not (1 <= c <= n):
+            return None
+        return sequence[c - 1]
+
+    resolved: list[StepCausation] = []
+    for i, dto in enumerate(step_dtos):
+        source = parse(dto.from_alias)
+        target = parse(dto.to_alias)
+        if source is None or target is None:
+            if len(step_dtos) != n:
+                return []  # aliases garbled and counts don't line up — drop all
+            source = sequence[i]
+            target = sequence[(i + 1) % n]
+        causation = dto.causation
+        for technical_alias, text in alias_translations.items():
+            causation = dc_replace(causation, technical_alias, text)
+        assert source.hash is not None and target.hash is not None
+        resolved.append(
+            StepCausation(
+                source_hash=source.hash,
+                target_hash=target.hash,
+                source_text=source.text,
+                target_text=target.text,
+                causation=causation,
+            )
+        )
+    return resolved
+
+
 class CausalCyclesDeckDto(BaseModel):
     causal_cycles: list[CausalCycleDto] = Field(
         ...,
@@ -121,41 +204,37 @@ class CausalityEstimatorBalanced(CausalityEstimator):
     def input_resolver(self) -> InputResolver:
         return self._input_resolver
 
-    def prompt_assess_multiple_sequences(
-        self, *, sequences: list[str]
-    ) -> list:
-        sequences_text = "\n".join(f"- {s}" for s in sequences)
-        return [llm.messages.user(
-            f"Which of the following circular causality sequences provides the best assessment "
-            f"considering realism, desirability, and feasibility "
-            f"(given that the final step cycles back to the first step):\n"
-            f"{sequences_text}\n\n"
-            f"<instructions>\n"
-            f"For each sequence:\n"
-            f"1) Estimate the numeric probability (0 to 1) considering realistic existence, optimal outcomes, and (implementation) feasibility — weigh these together holistically into a single plausibility score\n"
-            f"2) Explain why this sequence might occur (or already occurs) in reality\n"
-            f"3) Describe circumstances or contexts where this sequence would be most applicable or useful\n\n"
-            f"- Only use the sequences **exactly as provided**, do not shorten, skip, collapse, or reorder steps.\n"
-            f"</instructions>\n\n"
-            f"<formatting>\n"
-            f"- Output each circular causality sequence (cycle) as ordered aliases (technical placeholders) of statements as provided e.g. C1_1, C1_2, C1_3, ...\n"
-            f"- In the explanations, for fluency, use explicit wording instead of aliases.\n"
-            f"- Probability is a float between 0 and 1.\n"
-            f"</formatting>"
-        )]
+    def _lens_phrase(self) -> str:
+        """Assessment lens inserted after 'Assess the following circular causality sequence'."""
+        return "considering realism, desirability, and feasibility"
+
+    def _probability_instruction(self) -> str:
+        """Qualifier inserted after 'Estimate the numeric probability (0 to 1)'."""
+        return (
+            "considering realistic existence, optimal outcomes, and (implementation) "
+            "feasibility — weigh these together holistically into a single plausibility score"
+        )
 
     def prompt_assess_single_sequence(self, *, sequence: str) -> list:
+        """
+        Single prompt template shared by all estimator variants.
+
+        Subclasses customize only _lens_phrase() and _probability_instruction();
+        the sequence handling, instructions, and formatting rules stay identical.
+        """
         return [llm.messages.user(
-            f"Assess the following circular causality sequence considering realism, desirability, and feasibility "
+            f"Assess the following circular causality sequence {self._lens_phrase()}\n"
             f"(given that the final step cycles back to the first step):\n"
             f"{sequence}\n\n"
             f"<instructions>\n"
-            f"1) Estimate the numeric probability (0 to 1) considering realistic existence, optimal outcomes, and (implementation) feasibility — weigh these together holistically into a single plausibility score\n"
-            f"2) Explain why this sequence might occur (or already occurs) in reality\n"
-            f"3) Describe circumstances or contexts where this sequence would be most applicable or useful\n\n"
+            f"1) For each consecutive step of the sequence (including the final wrap-around step back to the first element), state in one sentence the causal mechanism: why does the source naturally lead to the target?\n"
+            f"2) Only then, informed by the step-by-step causation, estimate the numeric probability (0 to 1) {self._probability_instruction()}\n"
+            f"3) Explain why this sequence might occur (or already occurs) in reality\n"
+            f"4) Describe circumstances or contexts where this sequence would be most applicable or useful\n\n"
             f"- Only use the sequence **exactly as provided**, do not shorten, skip, collapse, or reorder steps.\n"
             f"</instructions>\n\n"
             f"<formatting>\n"
+            f"- In each step, identify source and target by their technical aliases exactly as given in the sequence; write the causation sentence itself using the actual statement wording, never aliases.\n"
             f"- In the explanations and argumentation, for fluency, try to use explicit wording instead of technical aliases.\n"
             f"- Probability is a float between 0 and 1.\n"
             f"</formatting>"
@@ -289,6 +368,7 @@ class CausalityEstimatorBalanced(CausalityEstimator):
             assessment: CausalCycleAssessmentDto = await _estimate_single_call()
             return CausalCycleDto(
                 aliases=aliases,
+                steps=assessment.steps,
                 probability=assessment.probability,
                 reasoning_explanation=assessment.reasoning_explanation,
                 argumentation=assessment.argumentation,
@@ -364,33 +444,14 @@ class CausalityEstimatorBalanced(CausalityEstimator):
             i: structure for i, structure in enumerate(structures)
         }
 
-        # Build component-alias translations for text replacement
-        components_with_aliases: list[tuple[Statement, str]] = []
-        for sequence in sequences:
-            for comp in sequence:
-                assert comp.hash is not None
-                alias = None
-                for existing_comp, existing_alias in components_with_aliases:
-                    if existing_comp.hash == comp.hash:
-                        alias = existing_alias
-                        break
-                if alias is None:
-                    alias = f"C{len(components_with_aliases) + 1}"
-                    components_with_aliases.append((comp, alias))
-
-        # Build alias translation map
-        id_to_original_alias: dict[str, str] = {}
-        for comp, original_alias in components_with_aliases:
-            assert comp.hash is not None
-            id_to_original_alias[comp.hash] = original_alias
+        # Translate technical aliases to statement text. Aliases are
+        # batch-relative and must never survive into persisted rationale
+        # prose — statement text is the only durable identifier.
         alias_translations: dict[str, str] = {}
         for seq_idx, sequence in enumerate(sequences, 1):
             for comp_idx, component in enumerate(sequence, 1):
                 technical_alias = f"C{seq_idx}_{comp_idx}"
-                assert component.hash is not None
-                original_alias = id_to_original_alias.get(component.hash)
-                if original_alias:
-                    alias_translations[technical_alias] = original_alias
+                alias_translations[technical_alias] = component.text
 
         # Map results
         results: dict[str, EstimationStructured] = {}
@@ -417,18 +478,22 @@ class CausalityEstimatorBalanced(CausalityEstimator):
             # Translate aliases in text
             reasoning_text = causal_cycle.reasoning_explanation
             argumentation_text = causal_cycle.argumentation
-            for technical_alias, original_alias in alias_translations.items():
-                reasoning_text = dc_replace(
-                    reasoning_text, technical_alias, original_alias
-                )
+            for technical_alias, text in alias_translations.items():
+                reasoning_text = dc_replace(reasoning_text, technical_alias, text)
                 argumentation_text = dc_replace(
-                    argumentation_text, technical_alias, original_alias
+                    argumentation_text, technical_alias, text
                 )
 
             results[matched_structure.hash] = EstimationStructured(
                 probability=causal_cycle.probability,
                 reasoning=reasoning_text,
                 argumentation=argumentation_text,
+                steps=_resolve_steps(
+                    causal_cycle.steps,
+                    sequences[seq_idx],
+                    seq_idx + 1,
+                    alias_translations,
+                ),
             )
 
         return results

dialectical_framework-1.6.2/src/dialectical_framework/concerns/causality/causality_estimator_criteria.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from dependency_injector.wiring import Provide, inject
+
+from dialectical_framework.enums.di import DI
+from dialectical_framework.concerns.causality.causality_estimator_balanced import \
+    CausalityEstimatorBalanced
+from dialectical_framework.protocols.input_resolver import InputResolver
+
+
+class CausalityEstimatorCriteria(CausalityEstimatorBalanced):
+    """
+    Causality estimator that uses custom assessment criteria.
+
+    Instead of the balanced/realistic/desirable/feasible perspective,
+    this estimator evaluates sequences against pre-formulated criteria
+    derived from a free-form exploration intent.
+
+    Criteria formulation happens upstream (in BuildWheels).
+    """
+
+    @inject
+    def __init__(
+        self,
+        criteria: str,
+        input_resolver: InputResolver = Provide[DI.input_resolver],
+    ):
+        super().__init__(input_resolver=input_resolver)
+        self._criteria = criteria
+
+    def _lens_phrase(self) -> str:
+        return f"with focus on the following assessment criteria: {self._criteria}"
+
+    def _probability_instruction(self) -> str:
+        return "with emphasis on the assessment criteria above"

dialectical_framework-1.6.2/src/dialectical_framework/concerns/causality/causality_estimator_desirable.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from dialectical_framework.concerns.causality.causality_estimator_balanced import \
+    CausalityEstimatorBalanced
+
+
+class CausalityEstimatorDesirable(CausalityEstimatorBalanced):
+
+    def _lens_phrase(self) -> str:
+        return "considering desirability, i.e. producing optimal outcomes and maximum results"
+
+    def _probability_instruction(self) -> str:
+        return "regarding how beneficial/optimal this sequence would be if implemented"

dialectical_framework-1.6.2/src/dialectical_framework/concerns/causality/causality_estimator_feasible.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from dialectical_framework.concerns.causality.causality_estimator_balanced import \
+    CausalityEstimatorBalanced
+
+
+class CausalityEstimatorFeasible(CausalityEstimatorBalanced):
+
+    def _lens_phrase(self) -> str:
+        return "considering feasibility, i.e. best achievable with minimum resistance"
+
+    def _probability_instruction(self) -> str:
+        return "regarding how easily this sequence could be implemented given current constraints"

dialectical_framework-1.6.2/src/dialectical_framework/concerns/causality/causality_estimator_realistic.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from dialectical_framework.concerns.causality.causality_estimator_balanced import \
+    CausalityEstimatorBalanced
+
+
+class CausalityEstimatorRealistic(CausalityEstimatorBalanced):
+
+    def _lens_phrase(self) -> str:
+        return "for realism, i.e. what typically happens in natural systems"
+
+    def _probability_instruction(self) -> str:
+        return "regarding its realistic existence in natural/existing systems"

{dialectical_framework-1.6.1 → dialectical_framework-1.6.2}/src/dialectical_framework/concerns/causality_estimation.py

@@ -3,8 +3,7 @@ CausalityEstimation: Concern for estimating causality on Cycles and Wheels.
 
 This is the "smart" orchestrator that:
 - Groups structures by type and size for parallel estimation
-- Decides what to estimate: if the requested group matches what's in the DB,
-  re-estimates everything; if DB has more, only estimates what was requested
+- (Re-)estimates exactly the structures requested
 - Normalizes probabilities across ALL structures of same type+size in the DB
 
 Usage:
@@ -61,9 +60,8 @@ class CausalityEstimation(ReasonableConcern[EstimationResult], SettingsAware):
       of same type+size in the DB
 
     Estimation logic per group:
-    - If the requested group IS the full set in the DB → re-estimate all
-    - If the DB has more structures → only estimate the ones requested
-    - Either way, normalization covers everything in the DB
+    - (Re-)estimates exactly the structures requested
+    - Normalization covers everything of same type+size in the DB
     """
 
     def __init__(self) -> None:
@@ -164,25 +162,17 @@ class CausalityEstimation(ReasonableConcern[EstimationResult], SettingsAware):
         Estimate a group of same-type, same-size structures.
 
         Logic:
-        - Find all structures of same type+size in DB
-        - If requested set IS the full DB set → estimate all (forced re-estimation)
-        - If DB has more → only estimate the requested ones
-        - Normalize probabilities across all DB structures
+        - (Re-)estimate exactly the requested structures
+        - Normalize probabilities across all structures of same type+size in DB
 
         Returns list of structures that were estimated.
         """
         # Find all structures of same type+size in DB
         all_in_db = self._find_all_in_layer(requested)
-        requested_hashes = {s.hash for s in requested}
-        db_hashes = {s.hash for s in all_in_db}
 
-        # Determine what to estimate
-        if requested_hashes == db_hashes:
-            # Requested set IS the full DB set → estimate all
-            to_estimate = requested
-        else:
-            # DB has more → only estimate what was requested
-            to_estimate = requested
+        # Always (re-)estimate exactly what was requested; normalization
+        # below covers everything in the DB layer.
+        to_estimate = requested
 
         # Run AI estimation (returns raw, non-normalized results)
         raw_estimations = await estimator.estimate(to_estimate)
@@ -258,7 +248,11 @@ class CausalityEstimation(ReasonableConcern[EstimationResult], SettingsAware):
         """
         Persist raw estimations to the database.
 
-        Creates Rationale + CausalityProbabilityEstimation for each structure.
+        Per structure: replaces prior causality rationales (holistic and
+        per-step), then creates Rationale + CausalityProbabilityEstimation
+        plus one per-step causation Rationale per sequence step (wheel steps
+        target their edge Transition; cycle steps target the Cycle itself,
+        self-identified by statement-text headers).
         """
         estimation_manager = EstimationManager()
 
@@ -268,15 +262,82 @@ class CausalityEstimation(ReasonableConcern[EstimationResult], SettingsAware):
 
             est = raw_estimations[structure.hash]
 
-            # Create Rationale
-            rationale = Rationale(
-                text=est.reasoning,
-                summary=est.argumentation,
-            )
+            # Replace: re-estimation supersedes prior explanations, on the
+            # structure itself and (for wheels) on its edge Transitions
+            self._delete_prior_rationales(structure)
+
+            # Create Rationale (argumentation folded into text — it used to be
+            # stored as an undeclared, write-only `summary` field)
+            rationale_text = est.reasoning
+            if est.argumentation:
+                rationale_text = (
+                    f"{est.reasoning}\n\n**Applicable contexts:** {est.argumentation}"
+                )
+            rationale = Rationale(text=rationale_text)
             rationale.set_explanation_target(structure)
             rationale.commit()
+            self._report.node_created(rationale)
 
             # Store raw AI score as CausalityProbabilityEstimation
             estimation_manager.upsert_estimation(
                 structure, CausalityProbabilityEstimation, est.probability, provider=rationale
             )
+
+            self._persist_step_causations(structure, est)
+
+    def _delete_prior_rationales(self, structure: Union[Cycle, Wheel]) -> None:
+        """Delete rationales explaining the structure (and its wheel edges)."""
+        from dialectical_framework.graph.repositories.node_repository import (
+            NodeRepository,
+        )
+
+        node_repo = NodeRepository()
+        targets: list = [structure]
+        if isinstance(structure, Wheel):
+            targets.extend(structure.edges)
+
+        for target in targets:
+            for old_rationale, _ in target.rationales.all():
+                self._report.node_deleted(old_rationale)
+            node_repo.delete_explanation_rationales(target)
+
+    def _persist_step_causations(
+        self, structure: Union[Cycle, Wheel], est: EstimationStructured
+    ) -> None:
+        """
+        Persist per-step causation rationales.
+
+        Wheel: each step attaches to the edge Transition matched by
+        (source hash, target hash) — never by index, since edge ordering
+        starts at an arbitrary edge. Cycle has no edge nodes, so steps
+        attach to the Cycle itself with a statement-text header; the same
+        header fallback applies to wheel steps that match no edge.
+        """
+        if not est.steps:
+            return
+
+        edge_by_hashes: dict[tuple[str, str], object] = {}
+        if isinstance(structure, Wheel):
+            for edge in structure.edges:
+                source_result = edge.source.get()
+                target_result = edge.target.get()
+                if source_result and target_result:
+                    key = (source_result[0].hash, target_result[0].hash)
+                    edge_by_hashes[key] = edge
+
+        for step in est.steps:
+            if not step.causation:
+                continue
+            edge = edge_by_hashes.get((step.source_hash, step.target_hash))
+            if edge is not None:
+                # The edge Transition itself identifies source/target
+                rationale = Rationale(text=step.causation)
+                rationale.set_explanation_target(edge)
+            else:
+                # No anchor node — the header makes the step self-describing
+                rationale = Rationale(
+                    text=f"**{step.source_text} → {step.target_text}**\n{step.causation}"
+                )
+                rationale.set_explanation_target(structure)
+            rationale.commit()
+            self._report.node_created(rationale)

{dialectical_framework-1.6.1 → dialectical_framework-1.6.2}/src/dialectical_framework/concerns/synthesis_generation.py

@@ -261,17 +261,21 @@ class SynthesisGeneration(ReasonableConcern[Optional[SynthesisResult]], Settings
         source_label = "?"
         target_label = "?"
 
+        # Alias + statement text: aliases alone are wheel-relative and would be
+        # the LLM's only grounding — self-describing labels prevent alias leaks
         if source_segment:
             core = source_segment.t.get()
             if core:
                 stmt, rel = core
-                source_label = rel.alias if hasattr(rel, "alias") else stmt.text
+                alias = getattr(rel, "alias", None)
+                source_label = f"{alias} ({stmt.text})" if alias else stmt.text
 
         if target_segment:
             core = target_segment.t.get()
             if core:
                 stmt, rel = core
-                target_label = rel.alias if hasattr(rel, "alias") else stmt.text
+                alias = getattr(rel, "alias", None)
+                target_label = f"{alias} ({stmt.text})" if alias else stmt.text
 
         return f"### Step {index}: {source_label} → {target_label}"
 

{dialectical_framework-1.6.1 → dialectical_framework-1.6.2}/src/dialectical_framework/concerns/transformation_generation.py

@@ -158,6 +158,7 @@ APEX
 5. **Ac+ must contradict Re-** (positive action opposes regression toward T-)
 6. Re- and Ac- typically have lower insight than the "+" aspects
 7. Statements are a fuller actionable form, longer than the headline
+8. In headline/statement/explanation prose, refer to concepts by their actual statement wording — never by T/A/T+/A-/Ac+/Re- notation. The notation is context-relative and meaningless to anyone reading the stored text later.
 
 ## Example (1-PP: T = Love, A = Indifference)
 

{dialectical_framework-1.6.1 → dialectical_framework-1.6.2}/src/dialectical_framework/graph/repositories/node_repository.py

@@ -134,3 +134,44 @@ class NodeRepository:
         if node_type is not None and not isinstance(node, node_type):
             raise TypeError(f"Expected {node_type.__name__}, got {type(node).__name__}")
         return node
+
+    @inject
+    def delete_explanation_rationales(
+        self,
+        node: BaseNode,
+        sid: Optional[str] = Provide[DI.sid],
+        graph_db: Union[Memgraph, Neo4j] = Provide[DI.graph_db],
+    ) -> list[str]:
+        """
+        Delete all Rationales that EXPLAIN the given node (with their critiques).
+
+        Used to replace prior analytical explanations before persisting fresh
+        ones (e.g. re-estimation of causality). Critique rationales attached
+        to the deleted rationales are removed as well.
+
+        Args:
+            node: The explained node (must be saved and in current scope)
+            sid: Case ID (injected from DI context)
+
+        Returns:
+            Hashes of the deleted Rationale nodes (for event emission)
+        """
+        if node._id is None:
+            return []
+
+        # Validate node belongs to current scope
+        if sid and node.sid != sid:
+            return []
+
+        query = """
+        MATCH (rat:Rationale)-[:EXPLAINS]->(n)
+        WHERE id(n) = $node_id
+        OPTIONAL MATCH (crit:Rationale)-[:CRITIQUES]->(rat)
+        WITH collect(DISTINCT rat) + collect(DISTINCT crit) AS to_delete
+        UNWIND to_delete AS r
+        WITH DISTINCT r, r.hash AS rat_hash
+        DETACH DELETE r
+        RETURN rat_hash
+        """
+        results = list(graph_db.execute_and_fetch(query, {"node_id": node._id}))
+        return [r["rat_hash"] for r in results if r["rat_hash"] is not None]

{dialectical_framework-1.6.1 → dialectical_framework-1.6.2}/src/dialectical_framework/utils/dc_replace.py

@@ -24,14 +24,15 @@ def dc_replace(text: str, alias: str, replace_to: str) -> str:
     - `(?<!\\w)`: Not preceded by word character (prevents "AT-" matching)
     - `(["'([{]?)`: Optional opening bracket/quote (captured)
     - `<alias>`: The literal alias (escaped)
-    - `(\\s|[]'"}).,!?:]|$)`: Followed by space, punctuation, or end (captured)
+    - `(\\s|[]'"});,.!?:/—-]|$)`: Followed by space, punctuation, or end (captured)
     """
     return re.sub(
         r'(?<!\w)(["\'\(\[\{]?)'
         rf"{re.escape(alias)}"
-        r"(\s|[\]\'\"\)\},.!?:]|$)",
-        # Replacement pattern (preserves surrounding characters and spaces)
-        r"\1" rf"{replace_to}" r"\2",
+        r"(\s|[\]\'\"\)\};,.!?:/—-]|$)",
+        # Function replacement: replace_to is arbitrary prose and must not be
+        # interpreted as a regex replacement template (backslashes, \1, etc.)
+        lambda m: m.group(1) + replace_to + m.group(2),
         text,
         flags=re.VERBOSE,
     )