dialectical-framework 2.0.2__tar.gz → 2.0.4__tar.gz

{dialectical_framework-2.0.2 → dialectical_framework-2.0.4}/PKG-INFO

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

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

@@ -324,12 +324,7 @@ class Consultant:
         if messages:
             self._conversation.load_messages(messages)
         parts = [p for p in (preamble, method_prompt(include_decision)) if p]
-        # Kept because the view turn's system prompt is this text plus the
-        # static half of its request (`exploration_view`): appending keeps the
-        # head a PREFIX of it, so the chat turns' cached prefix is readable by
-        # the sketch turns instead of each paying for its own.
-        self._system_prompt = "\n\n".join(parts)
-        self._conversation.set_system_prompt(self._system_prompt)
+        self._conversation.set_system_prompt("\n\n".join(parts))
 
     async def chat(self, user_message: str) -> str:
         result = await self._conversation.submit(ChatResponse, user_message)
@@ -367,8 +362,7 @@ class Consultant:
         view shows what has been ESTABLISHED, and where `focus` asks for
         structure not yet worked out ("a perspective for the thesis you
         named") the turn builds it by the method first
-        (`concerns/view_sketch.py`: the static instructions ride on the system
-        prompt, the focus is the turn). What it built is
+        (`concerns/view_sketch.py::view_sketch_prompt`). What it built is
         kept in `messages` as the consultant's own words, so the next turn can
         be asked about a corner it just drew.
 
@@ -386,8 +380,7 @@ class Consultant:
         """
         from dialectical_framework.concerns.view_sketch import (
             ViewSketchDto, exploration_view_from_sketch, history_ask,
-            history_text, perspective_from_sketch, view_sketch_focus,
-            view_sketch_instructions)
+            history_text, perspective_from_sketch, view_sketch_prompt)
 
         import asyncio
         import dataclasses
@@ -397,19 +390,19 @@ class Consultant:
 
         level = self._conversation._thinking_kwargs().get("thinking")
         history = self._conversation._messages
-        # The request travels in two places, not one. Its static half
-        # (definitions, rules, the build procedure) goes on the SYSTEM prompt,
-        # after this head's own, because that is where the provider's cache
-        # breakpoint sits: as part of the user message it followed the history
-        # and was re-prefilled at full rate on every draw (~1.2k tokens x N a
-        # card, measured 2026-10-06). Only the focus — the person's own ask —
-        # is the turn. Same words, and the history record is untouched
-        # (`history_ask`, which is why the long request was never kept anyway).
-        system = (
-            f"{self._system_prompt}\n\n"
-            f"{view_sketch_instructions(self._conversation.settings.component_length)}"
-        )
-        ask = view_sketch_focus(focus)
+        # The WHOLE request is the turn's user message, its "Answer with ONE
+        # JSON object" included — by measurement, not habit. For one day
+        # (2026-10-06) the static instructions rode on the system prompt so the
+        # cache would cover them (~$0.007 a card) and only "What to show: ..."
+        # was the turn. First cards did not notice; a RETRY did: its history
+        # already holds "Show me: ..." and the previous drawing in PROSE, and with
+        # a bare focus as the last user turn the model answered in prose too —
+        # 1.75 parse retries a retry card, 4.75 view-turn calls instead of 3,
+        # 33 s instead of 20 (`tests/e2e/probe_view_turn_retry_calls.py`, 8
+        # utterances; the first app had measured the same 4.6 calls and +17 s).
+        # The request->prose pair `history_ask` keeps OUT of the history is the
+        # same trap; the long request as the last turn is what holds the format.
+        request = view_sketch_prompt(focus, self._conversation.settings.component_length)
 
         async def draw() -> ViewSketchDto:
             # Each draw works on a COPY of the history: the turns run in
@@ -417,8 +410,7 @@ class Consultant:
             # read. What the view leaves behind is appended once, below.
             sketch_turn = ConversationFacilitator(format_mode="json", thinking=level)
             sketch_turn._messages = list(history)
-            sketch_turn.set_system_prompt(system)
-            return await sketch_turn.submit(ViewSketchDto, ask)
+            return await sketch_turn.submit(ViewSketchDto, request)
 
         n = clamp_attempts(attempts)
         # Fully parallel, deliberately. On a COLD cache all N draws write the

{dialectical_framework-2.0.2 → dialectical_framework-2.0.4}/src/dialectical_framework/concerns/control_statements_check.py

@@ -32,7 +32,7 @@ from __future__ import annotations
 
 import asyncio
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Optional, Sequence
+from typing import TYPE_CHECKING
 
 from pydantic import BaseModel, Field
 
@@ -97,74 +97,15 @@ class CoherenceEvaluationDto(BaseModel):
     )
 
 
-class TetradCoherenceDto(BaseModel):
-    """One tetrad's two control statements, from the JOINT call.
-
-    No DV field, deliberately. DV is an annotation that only `resolve`
-    persists (`DialecticalValidityEstimation`) and nothing reads it when
-    choosing among drafts — `SketchVerdict` has no DV term — so asking for it
-    here would buy output tokens and nothing else. A draft that goes on to be
-    persisted is scored by `resolve` afterwards, DV and all.
-    """
-
-    tetrad: int = Field(
-        description=(
-            "The number of the tetrad this verdict scores, exactly as labelled "
-            "in the request."
-        )
-    )
-    t_plus_without_a_plus_yields_t_minus: float = Field(
-        ge=0.0,
-        le=1.0,
-        description="Conceptual Coherence (0.0-1.0) of that tetrad's statement (a).",
-    )
-    a_plus_without_t_plus_yields_a_minus: float = Field(
-        ge=0.0,
-        le=1.0,
-        description="Conceptual Coherence (0.0-1.0) of that tetrad's statement (b).",
-    )
-    reasoning: str = Field(
-        description=(
-            "One sentence on the weaker of that tetrad's two statements. A note, "
-            "not an essay."
-        )
-    )
-
-
-class JointCoherenceEvaluationDto(BaseModel):
-    """Every tetrad of one request, scored in one call."""
-
-    verdicts: list[TetradCoherenceDto] = Field(
-        description=(
-            "One entry per tetrad in the request, in the request's order. Score "
-            "every tetrad; omit none."
-        )
-    )
-
-
-@dataclass(frozen=True)
-class TetradTexts:
-    """The four aspect texts of one tetrad — all the control statements need.
-
-    What `score_texts_many` takes, so a caller holding several drafts as text
-    cannot mix up the order of four positional strings.
-    """
-
-    t_plus: str
-    t_minus: str
-    a_plus: str
-    a_minus: str
-
-
 def control_statements(
     *, t_plus: str, t_minus: str, a_plus: str, a_minus: str
 ) -> tuple[str, str]:
     """The paper's two control statements, built from four texts.
 
-    One builder for all three askers (`resolve` off a committed Perspective,
-    `score_texts` and `score_texts_many` off bare texts) so the quoting cannot
-    drift: a verdict taken before persistence and one taken after must be the
-    same question asked of the same words.
+    One builder for both askers (`resolve` off a committed Perspective,
+    `score_texts` off bare texts) so the quoting cannot drift: a verdict taken
+    before persistence and one taken after must be the same question asked of
+    the same words.
     """
     return (
         f'"{t_plus}" without "{a_plus}" yields "{t_minus}"',
@@ -172,13 +113,12 @@ def control_statements(
     )
 
 
-# --- Shared prompt text ---
+# --- Prompt text ---
 #
-# Written once because two prompts ask for it: one statement at a time
-# (`_evaluate_control_statement`, for `resolve` and `score_texts`) and all of
-# several tetrads at once (`score_texts_many`). Re-typed inline the scales
-# would drift, and a verdict from one prompt is ranked against a verdict from
-# the other (`concerns/tetrad_candidates.py`).
+# The pattern and the two scales of `_evaluate_control_statement`, as constants
+# so a probe can put the SAME scales in front of a candidate judge
+# (`tests/e2e/probe_joint_judge_stability.py` did, 2026-10-06, and rejected two
+# cheaper shapes against this one).
 
 _PATTERN = """The pattern "[Positive] without [Balancing factor] yields [Negative]" tests whether
 the absence of a balancing positive aspect naturally leads to the negative/shadow aspect."""
@@ -372,14 +312,12 @@ class ControlStatementsCheck(ReasonableConcern[ControlStatementsCheckResult]):
         """The two control statements on bare texts — no Perspective, no graph.
 
         What `resolve` does after reading the four aspects off a committed
-        node, for a caller holding ONE tetrad as text and wanting DV with it.
-        Built by the same statement builder as `resolve`, so a verdict here is
-        the same question as the one asked after persistence.
-
-        Not what best-of-N selection uses: a field of drafts goes through
-        `score_texts_many`, which asks once for all of them and leaves DV out
-        (nothing in selection reads it). Two statements, two calls, both with
-        reasoning, is the shape that made judging a third of a card's cost.
+        node, offered to callers that hold a tetrad as text: the best-of-N
+        selector (`concerns/tetrad_candidates.py`) and the harness. Built by
+        the same statement builder and asked with the same prompt as `resolve`,
+        so a verdict here is the same question as the one asked after
+        persistence. Two calls per tetrad is the cost of that: the cheaper
+        shapes measured against it disagreed (`tetrad_candidates.judge_sketches`).
         """
         stmt_1, stmt_2 = control_statements(
             t_plus=t_plus, t_minus=t_minus, a_plus=a_plus, a_minus=a_minus
@@ -389,73 +327,6 @@ class ControlStatementsCheck(ReasonableConcern[ControlStatementsCheckResult]):
             self._evaluate_control_statement(stmt_2, text),
         )
 
-    async def score_texts_many(
-        self,
-        tetrads: Sequence[TetradTexts],
-        *,
-        text: str = "",
-    ) -> list[Optional[TetradCoherenceDto]]:
-        """Several tetrads' control statements, all in ONE call.
-
-        What `score_texts` asks for one draft at a time, asked for a whole
-        best-of-N field at once. Measured reason (2026-10-06, the first app's
-        real entry points through `utils/call_census.py`): per-statement calls
-        made judging 6 of the 11 provider calls behind one card and ~3.3k of
-        its ~5.1k output tokens — about a third of the card's cost — because
-        each call spent ~550 output tokens of reasoning on one sentence. One
-        call with a short note per tetrad replaces six.
-
-        The question is unchanged and so is its discipline: the judge sees
-        only each tetrad's four aspects (never the thesis or antithesis, see
-        `concerns/tetrad_candidates.py`), the statements are built by the same
-        builder `resolve` uses, and the prompt forbids comparing the drafts —
-        selection stays among independent draws. CC only; `TetradCoherenceDto`
-        says why DV is not asked for here.
-
-        Fail-soft per tetrad: a verdict the model omits, or labels with a
-        number that is out of range or already filled, comes back `None` for
-        that tetrad rather than shifting every later one onto the wrong draft.
-        """
-        if not tetrads:
-            return []
-
-        blocks = []
-        for n, tetrad in enumerate(tetrads, 1):
-            stmt_a, stmt_b = control_statements(
-                t_plus=tetrad.t_plus,
-                t_minus=tetrad.t_minus,
-                a_plus=tetrad.a_plus,
-                a_minus=tetrad.a_minus,
-            )
-            blocks.append(f"Tetrad {n}:\n(a) {stmt_a}\n(b) {stmt_b}")
-
-        context_section = f"<context>\n{text}\n</context>\n\n" if text else ""
-        joined = "\n\n".join(blocks)
-        prompt = f"""{context_section}Rate the control statements of {len(tetrads)} tetrads. Each tetrad has two statements, (a) and (b).
-
-{joined}
-
-{_PATTERN}
-
-Rate every statement on one scale:
-
-{_CC_SCALE}
-
-Score each tetrad on its own, against the pattern above and nothing else. These are independent drafts: do not compare them with each other, do not rank them, do not pick a best, and do not let one tetrad's wording move another's score. The order they appear in carries no information. Return one verdict per tetrad, labelled with that tetrad's number."""
-
-        conversation = ConversationFacilitator()
-        result = await conversation.submit(
-            response_model=JointCoherenceEvaluationDto,
-            user_content=prompt,
-        )
-
-        placed: list[Optional[TetradCoherenceDto]] = [None] * len(tetrads)
-        for verdict in result.verdicts:
-            index = verdict.tetrad - 1
-            if 0 <= index < len(placed) and placed[index] is None:
-                placed[index] = verdict
-        return placed
-
     async def _evaluate_control_statement(
         self,
         statement: str,

{dialectical_framework-2.0.2 → dialectical_framework-2.0.4}/src/dialectical_framework/concerns/synthesis_generation.py

@@ -30,6 +30,8 @@ from dialectical_framework.agents.conversation_facilitator import (
     ConversationFacilitator,
 )
 from dialectical_framework.agents.reasonable_concern import ReasonableConcern
+from dialectical_framework.concerns.transformation_sketch import (
+    SYNTHESIS_SHAPE, TRANSFORMATION_POSITIONS)
 from dialectical_framework.graph.nodes.statement import Statement
 from dialectical_framework.protocols.has_config import SettingsAware
 
@@ -39,7 +41,12 @@ if TYPE_CHECKING:
     from dialectical_framework.graph.nodes.wheel import Wheel
 
 
-SYSTEM_PROMPT = """You are an expert in dialectical synthesis — the emergent properties arising from circular causality loops.
+#: "The shape of the inputs" is the framework's ONE statement of the
+#: Transformation (`transformation_sketch.TRANSFORMATION_POSITIONS`) and of S±
+#: (`SYNTHESIS_SHAPE`), not a copy: this prompt reads graph-built
+#: Transformations and the one-shot writes them, and the two must not define
+#: Ac-/Re- differently (2026-10-06 — this paragraph had dropped where Ac- GOES).
+SYSTEM_PROMPT = f"""You are an expert in dialectical synthesis — the emergent properties arising from circular causality loops.
 
 ## What Synthesis IS
 
@@ -57,7 +64,7 @@ S+ produces new qualitative dimensions — it increases a system's capacity for
 ## S- (Negative Synthesis): Collapse Pattern (1+1<2)
 
 S- emerges when the failure modes (Ac- and Re-) reinforce each other:
-- Acting without reflecting yields Ac- (the action's own drift); reflecting without acting yields Re- (the reflection's own regression)
+- Ac+ without Re+ yields Ac- (the action's own drift, which carries T+ into A-); Re+ without Ac+ yields Re- (the reflection's own regression, which carries A+ into T-)
 - Together these create downward spirals — dominance of one pole, or unstable oscillation between them
 - Diversity is reduced and qualitative growth is replaced by quantitative amplification
 
@@ -65,7 +72,11 @@ S- manifests as imitation rather than transformation: external forms, metrics, o
 
 ## The shape of the inputs, exactly
 
-Each Transformation is itself a tetrad: Ac (the action) and Re (the reflection) are its poles; Ac+/Ac- and Re+/Re- are their constructive and one-sided developments. So Ac- is the ACTION gone wrong and Re- is the REFLECTION gone wrong — they are not the segments' own traps (T-, A-) restated, and S- is not those traps either. S- is the ONE named state the degraded action and the degraded reflection produce together: a single way of failing that is neither trap on its own and not a choice between them. "Either X or Y", "X versus Y" and "X while Y" with X and Y the two traps are the inputs listed, not the collapse named. Likewise S+ is a gain in dimension the pathways produce together — not "both", not the two strengths listed side by side.
+Each Transformation is itself a tetrad, built this way:
+
+{TRANSFORMATION_POSITIONS}
+
+{SYNTHESIS_SHAPE}
 
 ## Requirements
 

{dialectical_framework-2.0.2 → dialectical_framework-2.0.4}/src/dialectical_framework/concerns/tetrad_candidates.py

@@ -31,12 +31,13 @@ holding a text or an object with `.statement` (`TetradDto`'s `AspectDto`).
 
 from __future__ import annotations
 
+import asyncio
 import logging
 from dataclasses import dataclass
 from typing import Any, Optional, Sequence
 
-from dialectical_framework.concerns.control_statements_check import (
-    ControlStatementsCheck, TetradTexts)
+from dialectical_framework.concerns.control_statements_check import \
+    ControlStatementsCheck
 from dialectical_framework.graph.nodes.estimation import \
     CONCEPTUAL_COHERENCE_THRESHOLD
 
@@ -108,78 +109,68 @@ def is_complete(candidate: Any) -> bool:
 async def judge_sketches(
     candidates: Sequence[Any], context: str = ""
 ) -> list[Optional[SketchVerdict]]:
-    """The validator's two control statements for EVERY candidate, in ONE call.
+    """The validator's two control statements for every candidate, each draft
+    judged on its own, each statement in its own call (gathered).
 
     Statement texts are built by the same builder `ControlStatementsCheck.resolve`
-    uses, so a verdict here and one taken after persistence are the same
-    question asked of the same words. The judge still sees only the four
-    aspects of each draft — never the thesis or the antithesis — and the
-    prompt forbids comparing the drafts with each other, so selection stays
-    "among independent draws" (this module's docstring) and this call cannot
-    be turned into regeneration.
-
-    Why one call: judging used to be a call per control statement per
-    candidate — 6 of the 11 provider calls behind one best-of-3 card, and
-    ~3.3k of its ~5.1k output tokens, about a third of its cost (measured
-    2026-10-06 on the first app's real entry points with
-    `utils/call_census.py`). One call with a short note per tetrad replaces
-    six long ones.
-
-    Fail-soft twice over. A verdict the model omits is `None` for that
-    candidate, which sorts last; a failed call leaves EVERY candidate
-    unjudged, which keeps the first draw — exactly what `attempts=1` would
-    have done. The second shape is new with the joint call and is the cost of
-    it: per-statement calls could lose one candidate's verdict and keep the
-    rest.
-
-    OPEN, because this was a cost change and not a quality one. Judge
-    stability was 92% on re-judging the same text when each statement had its
-    own call (`docs/dev-notes/antithesis-selection.md`, "Best-of-N"); the
-    joint call's stability, and its position bias (a candidate winning for
-    being listed first), are unmeasured — measure both with the same probe,
-    and the card quality with the app's paired eval, before reading any
-    quality claim into this. If stability falls below ~85%, the rung down is
-    one call per candidate with both statements in one DTO, which is still
-    half the output of the per-statement shape.
+    uses, and the prompt is the one `resolve` asks, so a verdict here and one
+    taken after persistence are the same question asked of the same words. The
+    judge sees only the four aspects of each draft, never the thesis or the
+    antithesis. Fail-soft per candidate: a judging that fails is `None` for
+    that draft alone, which sorts last.
+
+    Deliberately NOT cheaper, by measurement (2026-10-06,
+    `tests/e2e/probe_joint_judge_stability.py`, 40 stored triples). Judging is
+    the costliest part of a best-of-3 card (6 of its 11 calls, about a third of
+    its cost), and two cheaper shapes were tried and rejected:
+    - one call for the whole field: pass/fail agreement with the stored verdict
+      70% against this judge's own 92% on the same drafts, the same winner
+      across a reversed order in 7/40, the first-listed draft winning 29/40;
+      it picked by position and ties;
+    - one call per draft with both statements in it (the same lean prompt):
+      73% against 90%, the same winner as this judge in 23/40 — stable with
+      itself, but measuring something else;
+    - THIS prompt with each reasoning field capped at one short sentence
+      (the score is written before the reasoning, so the cap looked free):
+      output 534 -> 181 tokens a call, but 78% against 90%, scores +0.05, the
+      same winner as this judge in 29/40. The reasoning is not dead weight.
+    A cheaper judge has to be measured against this one on that probe first;
+    the owner closed the cost question at this point (2026-10-06).
     """
-    try:
-        verdicts = await ControlStatementsCheck().score_texts_many(
-            [
-                TetradTexts(
-                    t_plus=aspect_text(c.t_plus),
-                    t_minus=aspect_text(c.t_minus),
-                    a_plus=aspect_text(c.a_plus),
-                    a_minus=aspect_text(c.a_minus),
-                )
-                for c in candidates
-            ],
-            text=context,
-        )
-    except Exception as exc:  # noqa: BLE001 — degrade to "all unjudged"
-        logger.warning("Judging the sketches failed; the first draw is kept: %s", exc)
-        return [None] * len(candidates)
-    return [
-        None
-        if v is None
-        else SketchVerdict(
-            t_plus_without_a_plus=v.t_plus_without_a_plus_yields_t_minus,
-            a_plus_without_t_plus=v.a_plus_without_t_plus_yields_a_minus,
-            reasoning=v.reasoning,
-        )
-        for v in verdicts
-    ]
+
+    async def one(tension: Any) -> Optional[SketchVerdict]:
+        # Reading the verdict is inside the `try` too: a malformed response
+        # is a failed judging (sorts last), never a failed selection.
+        try:
+            first, second = await ControlStatementsCheck().score_texts(
+                t_plus=aspect_text(tension.t_plus),
+                t_minus=aspect_text(tension.t_minus),
+                a_plus=aspect_text(tension.a_plus),
+                a_minus=aspect_text(tension.a_minus),
+                text=context,
+            )
+            return SketchVerdict(
+                t_plus_without_a_plus=first.coherence_score,
+                a_plus_without_t_plus=second.coherence_score,
+                reasoning=f"{first.reasoning} / {second.reasoning}".strip(" /"),
+            )
+        except Exception as exc:  # noqa: BLE001 — degrade to "unjudged"
+            logger.warning("Judging a sketch failed; it sorts last: %s", exc)
+            return None
+
+    return list(await asyncio.gather(*(one(c) for c in candidates)))
 
 
 async def select_sketch(
     candidates: Sequence[Any], context: str = ""
 ) -> tuple[int, list[Optional[SketchVerdict]]]:
-    """Judge every candidate (one call) and return the index of the best plus
-    all verdicts (None where a verdict did not come back).
+    """Judge every candidate (gathered) and return the index of the best plus
+    all verdicts (None where judging failed).
 
     Ranking: the weaker control statement first (the pass rule), then the
     mean, then the earlier draw — a deterministic tie-break, not a preference.
-    An unjudged candidate sorts last; if no verdict came back at all the first
-    draw is kept, which is exactly what `attempts=1` would have done.
+    A candidate whose judging failed sorts last; if every judging failed the
+    first draw is kept, which is exactly what `attempts=1` would have done.
 
     ONE candidate is never judged: there is nothing to select among, so
     `attempts=1` costs no extra call.

{dialectical_framework-2.0.2 → dialectical_framework-2.0.4}/src/dialectical_framework/concerns/transformation_generation.py

@@ -248,7 +248,17 @@ class ReSideCompletionDto(BaseModel):
         description="Proactiveness category for Re+"
     )
 
-    # Re- fields
+    # Re- fields. The weak position of the staged generator, measured
+    # 2026-10-06 (`tests/e2e/probe_staged_endpoints.py`, 102 Transformations on
+    # 17 one-tension wheels, read with the theory-faithful `TransitionVerdict`):
+    # Re- valid 49% against Ac- 70%, and it is the LANDING that fails (59%
+    # land in T-; 27% valid on T->A edges). The prompt asked for "the
+    # reflection without the action", which the writer read as "keep watching,
+    # do nothing" — and wherever A is the passive pole, doing nothing is A's
+    # trap, not T's. Two `re_minus_from` / `re_minus_into` fields ahead of these
+    # (the one-shot's fix) moved it within noise and were reverted; the
+    # landing is now named in `_generate_re_side`'s Re- instruction instead.
+    # See docs/dev-notes/one-shot-transformation.md.
     re_minus_headline: str = Field(description="Re- headline (component length)")
     re_minus_statement: str = Field(description="Re- statement (fuller than the headline)")
     re_minus_explanation: str = Field(
@@ -641,7 +651,8 @@ Given their action, what reflection does it trigger that leads to growth?
 
 What happens when their action IS taken in, but nothing you do grounds that reflection?
 - What Re+ ITSELF degenerates into when Ac+ is absent — an overextension of the reflection, not the absence of one
-- Path: the Reflection Perspective's positive regresses you toward your negative
+- Where it LANDS is what makes it Re-: it ends in the A- line of <reflection_perspective> — YOUR OWN trap. It starts from that block's T+ line (the other side's strength); you need not name the start, but the landing must be your trap
+- The common miss: "keep watching and do nothing". When the other side is the passive one, doing nothing just leaves THEIR trap in place (the block's T- line) — that is not Re-. Re- is your reflecting, overdone, carrying YOU into your own trap
 - NOT the same failure as Ac-: Ac- is your action left unreflected, Re- is your reflection left unacted
 - Your Ac+ must CONTRADICT Re- (your positive action opposes this regression)
 - Usually lower insight than Re+