dialectical-framework 2.0.3__tar.gz → 2.0.5__tar.gz

{dialectical_framework-2.0.3 → dialectical_framework-2.0.5}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dialectical-framework"
-version = "2.0.3"
+version = "2.0.5"
 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.3 → dialectical_framework-2.0.5}/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.3 → dialectical_framework-2.0.5}/src/dialectical_framework/concerns/tetrad_candidates.py

@@ -129,8 +129,13 @@ async def judge_sketches(
       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.
-    A cheaper judge has to be measured against this one on that probe first.
+      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).
     """
 
     async def one(tension: Any) -> Optional[SketchVerdict]:

{dialectical_framework-2.0.3 → dialectical_framework-2.0.5}/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 42% against Ac- 71% (the corrected auditor, 2026-10-07), and it
+    # is the LANDING that fails (58% land in T-; 20% 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+

{dialectical_framework-2.0.3 → dialectical_framework-2.0.5}/src/dialectical_framework/concerns/transformation_sketch.py

@@ -32,9 +32,10 @@ state, scored 11/17 on the third-trap auditor where a call that skipped the
 poles and stated the theory loosely scored 0/17 (`one-shot-transformation.md`,
 arms 1 and 2; the auditor is saturated by the either/or instruction, so read
 that as compliance). The endpoint half of the minus definitions was added
-afterwards and, stated in text alone, did NOT land: the first app measured it
-at 14-30% and `tests/e2e/probe_transformation_sketch.py` at 22% / 18% (Ac- /
-Re-). What lands the ends is the DTO, not the sentence: the writer names where
+afterwards and, stated in text alone, did NOT land: valid Ac- / Re- in 30% /
+26% of drafts by the theory-faithful auditor (`probe_transition_rescore.py`;
+the app's stricter auditor read 14-30%). What lands the ends is the DTO, not
+the sentence: the writer names where
 each minus line starts and lands before writing it (`TransformationSketchDto`
 says why and by how much). That probe is the gate for any change to the
 definition text or those fields. Arm 1 is not evidence against the endpoints:
@@ -143,15 +144,27 @@ class TransformationSketchDto(BaseModel):
 
     `ac_minus_from` / `ac_minus_into` (and the Re- pair) come BEFORE their
     line on purpose, and they are the measured fix, not decoration. Stating the
-    ends in the definition does not make the writer use them: the shipped text
-    put Ac- on T+ -> A- in 22% of drafts and Re- on A+ -> T- in 18%, because
-    "the action without the reflection" reads like the tetrad's own "T+ without
-    A+ yields T-" and the line lands on T's OWN trap. Making the writer name
-    the start and the landing first moved both to 60% / 58% (+38 / +40, both
-    clearing noise), with the makeup reads and S- unchanged within noise
-    (`tests/e2e/probe_transformation_sketch.py`, 25 tetrads x 2 reps,
-    2026-10-06). A host may ignore the four scaffold fields; their job is done
-    by the time the line is written.
+    ends in the definition does not make the writer use them: with the text
+    alone a valid Ac- (lands in A-, is the action degenerated, the action
+    causing the landing) came back in 32% of drafts and a valid Re- in 30%, because "the
+    action without the reflection" reads like the tetrad's own "T+ without A+
+    yields T-" and the line lands on T's OWN trap. Making the writer name the
+    start and the landing first moved them to 62% / 64% (paired +30 / +34, both
+    clearing noise), S- unchanged (third failure 75% / 75%; crossed pairwise 57-56 over 113 decided pairs) (`tests/e2e/probe_transformation_sketch.py`,
+    25 tetrads x 2 reps, 2026-10-06, re-read by `probe_transition_rescore.py`
+    with the auditor two blind theory panels agree with on 54/60 clear cases;
+    the app's stricter auditor had read 22/18% -> 60/58%). A host may
+    ignore the four scaffold fields; their job is done by the time the line is
+    written.
+
+    The price, measured: the ends rose and the makeup reads dip a little — a
+    line written to land on its trap can stop reading as the operation
+    overdone. "Re- is the reflection itself" 94% -> 88% (within noise) in the
+    first run, "Ac- is the action itself" 100% -> 93% (-7, clears) in the
+    second (2026-10-07, 100 pairs); the first app's pill saw Re- 98% -> 80% in
+    its own voice. Against +30 / +34 on validity it is a good trade; if a
+    host's makeup read keeps falling, measure it on this probe, do not drop the
+    fields by eye.
 
     Hosts SUBCLASS it to add their own person-facing fields after these, so
     the derivation and the words that rest on it stay one call: the first
@@ -270,6 +283,13 @@ class TransformationSketch(ReasonableConcern[TransformationSketchDto], SettingsA
     class: it subclasses `TransformationSketchDto` and embeds
     `TRANSFORMATION_BUILD_PROCEDURE` in its own system prompt, so the theory
     is still the framework's and the voice is the host's.
+
+    A host that writes person-facing text from the result in a SECOND call
+    must tell that call the lines are meaning only, not wording to reuse:
+    otherwise it echoes them, and the lines are written to the theory's
+    shape, not to a person. Measured by the first app on its card text
+    (19–21 points lost until its writer said so; the record is in that app's
+    repo).
     """
 
     def __init__(self) -> None:

{dialectical_framework-2.0.3 → dialectical_framework-2.0.5}/src/dialectical_framework/concerns/view_sketch.py

@@ -186,22 +186,8 @@ For each pair:
 3. Re-read both aspects against step 1 for two distinct failures. (a) Wrong parent: if one is really the OTHER parent developed, rewrite it from its own parent. (b) {PLUS_RESTATEMENT_CHECK}"""
 
 
-def view_sketch_focus(focus: Optional[str]) -> str:
-    """The one per-call line of the request: what this draw is to show.
-
-    Split from the instructions so the Consultant can send this alone as the
-    turn's user message and carry the static half on the system prompt, where
-    the provider's cache breakpoint already sits (`view_sketch_instructions`).
-    """
-    return (
-        f"What to show: {focus}"
-        if focus and focus.strip()
-        else "What to show: the tensions this conversation has worked out so far."
-    )
-
-
-def view_sketch_instructions(max_words: int) -> str:
-    """The STATIC half of the view turn's request — everything but the focus.
+def view_sketch_prompt(focus: Optional[str], max_words: int) -> str:
+    """The structured turn's request, over the consultant's own conversation.
 
     Two instructions in one, because the ask is one or the other and the model
     knows which: render what is ESTABLISHED (a tension already named and taken
@@ -217,20 +203,15 @@ def view_sketch_instructions(max_words: int) -> str:
     (docs/dev-notes/antithesis-selection.md, 2026-10-02). The thesis is asked
     for as a STANCE (`THESIS_IS_A_STANCE`): on 20 questions the turn echoed the
     question as T in 6 before the ask was here (the alsotrue app repo, docs/lab-notes-entry.md).
-
-    Static because every word of it is fixed per deployment (`max_words` comes
-    from settings), which is what lets the Consultant append it to its system
-    prompt: as a user message it sat after the history and was re-prefilled at
-    full rate on every draw — ~1.2k tokens x N per card, measured 2026-10-06.
-    On the system prompt it rides inside the cached prefix. This is a cache
-    placement, not a content change; the one thing it does move is WHERE the
-    focus line sits, from just under the opening paragraph to the end of the
-    turn (`tests/e2e/probe_view_turn_ask.py` is the instrument if that is ever
-    suspected of mattering).
     """
+    focus_line = (
+        f"What to show: {focus}\n\n"
+        if focus and focus.strip()
+        else "What to show: the tensions this conversation has worked out so far.\n\n"
+    )
     return f"""Draw the structure of this conversation as dialectical tetrads. Answer with ONE JSON object in the requested schema and nothing else — no prose. Earlier drawings in this conversation are recorded in prose; that is their record, not the format of this answer.
 
-{ASPECT_DEFINITIONS}
+{focus_line}{ASPECT_DEFINITIONS}
 
 Rules for what goes in the view:
 - Show what this conversation has ESTABLISHED: a tension you named and the person took up is drawn as you both have it, in their terms. Do not re-derive what is already on the table.
@@ -247,17 +228,6 @@ Rules for what goes in the view:
 Write every position in the person's own terms, {max_words} words or fewer each."""
 
 
-def view_sketch_prompt(focus: Optional[str], max_words: int) -> str:
-    """The whole request as ONE user message: the instructions and the focus.
-
-    The shape for a caller with no system prompt of its own to append to — the
-    probes and the harness. The Consultant sends the two halves apart
-    (`view_sketch_instructions` on the system prompt, `view_sketch_focus` as
-    the turn), which is the same words in a different place.
-    """
-    return f"{view_sketch_instructions(max_words)}\n\n{view_sketch_focus(focus)}"
-
-
 # --- The view shaping (pure) ----------------------------------------------
 
 

{dialectical_framework-2.0.3 → dialectical_framework-2.0.5}/src/dialectical_framework/dialectical_reasoning.py

@@ -13,9 +13,30 @@ from dialectical_framework.graph.composite_input_resolver import CompositeInputR
 from dialectical_framework.agents.execution_report import ExecutionReport
 from dialectical_framework.events.graph_event_bus import GraphEventBus
 from dialectical_framework.graph.scope_context import get_current_sid
+from dialectical_framework.settings_context import (get_base_settings,
+                                                    get_current_settings,
+                                                    set_base_settings)
 from dialectical_framework.utils import progress
 
 
+class _PerRequestSettings(providers.Callable):
+    """`settings` resolved per request (`settings_context`), and NOT overridable.
+
+    An override would replace this provider with one fixed object and silently
+    put the whole process back on a single settings slot — every concurrent
+    request answering on whichever settings were set last. That was the only
+    per-user mechanism before 2026-10-07 and is the defect this exists to end,
+    so it fails loudly and names the replacement.
+    """
+
+    def override(self, provider):  # noqa: D102 - see the class docstring
+        raise RuntimeError(
+            "container.settings cannot be overridden: it is resolved per request. "
+            "Wrap the calls in `with using_settings(settings):` "
+            "(dialectical_framework.settings_context) instead."
+        )
+
+
 class DialecticalReasoning(containers.DeclarativeContainer):
     """
     Main DI container for the Dialectical Reasoning Framework.
@@ -29,9 +50,16 @@ class DialecticalReasoning(containers.DeclarativeContainer):
 
     @classmethod
     def setup(cls, settings: Settings) -> 'DialecticalReasoning':
-        """Create a new container instance with user-specific settings."""
+        """Create the container with the process's BASE settings.
+
+        The base is what every read sees outside a `using_settings(...)` scope,
+        and the only source of the read-once fields (graph connection, provider
+        timeout, effect log). Per-person settings in a server are
+        `using_settings` around each request, never another `setup()` and never
+        an override (`settings_context`).
+        """
         container = cls()
-        container.settings.override(settings)
+        set_base_settings(settings)
         ExecutionReport.set_event_bus(container.event_bus())
         # Same bus object, different channel (`sid:progress`). Wired separately
         # because progress is not a graph mutation — see `utils/progress.py`.
@@ -41,8 +69,10 @@ class DialecticalReasoning(containers.DeclarativeContainer):
             ExecutionReport.set_effect_logger(EffectLogger(settings.effect_log_dir))
         return container
 
-    # It will be the same settings for all services in the container
-    settings = providers.Dependency(instance_of=Settings)
+    # Per request: the innermost `using_settings(...)`, else the base (`settings_context`).
+    settings = _PerRequestSettings(get_current_settings)
+    # The base alone, for what is built ONCE per process (the graph connection).
+    base_settings = providers.Callable(get_base_settings)
 
     @staticmethod
     def _create_graph_db(settings: Settings) -> Union[Memgraph, Neo4j]:
@@ -228,9 +258,12 @@ class DialecticalReasoning(containers.DeclarativeContainer):
                 )
 
     # Graph database (Memgraph or Neo4j) for graph-native dialectical structures
+    # Built from the BASE, never the per-request settings: the connection is one
+    # Singleton per process, so whichever request first resolved it would
+    # otherwise decide the database for everyone.
     graph_db: providers.Singleton[Union[Memgraph, Neo4j]] = providers.Singleton(
         _create_graph_db,
-        settings=settings
+        settings=base_settings
     )
 
     # -- Content Resolution --

{dialectical_framework-2.0.3 → dialectical_framework-2.0.5}/src/dialectical_framework/settings.py

@@ -30,6 +30,21 @@ def _env_thinking_level() -> dict[str, Optional[str]]:
 
 
 class Settings(BaseModel):
+    """Framework configuration, in TWO TIERS by when a field is read.
+
+    Per request (read at call time, so `with using_settings(...)` from
+    `dialectical_framework.settings_context` scopes them to one asyncio context):
+    `ai_model`, `reasoning_model`, and everything read through
+    `SettingsAware.settings` — word limits, the thinking level, the Advisor's
+    floors and caps, the audit switches.
+
+    Per process (read once, from the base `DialecticalReasoning.setup()` installs;
+    a value inside `using_settings` has no effect): `graph_db_*` (the connection is
+    a Singleton), `llm_connect_timeout_s` (the provider is registered once),
+    `effect_log_dir` (installed in `setup`). `DIALEXITY_MAX_CONCURRENT_LLM_CALLS`
+    is not a field at all: an env var behind one process-wide semaphore.
+    """
+
     model_config = ConfigDict(
         arbitrary_types_allowed=True,
     )

dialectical_framework-2.0.5/src/dialectical_framework/settings_context.py

@@ -0,0 +1,104 @@
+"""
+Settings per request: a ContextVar over a process base, the way `sid` works.
+
+WHY
+===
+The container's `settings` used to be ONE slot (`providers.Dependency`, filled by
+`DialecticalReasoning.setup`). A host serving many people from one process could
+only change a person's settings with `container.settings.override(...)`, which
+swaps the slot for EVERY call in flight: two concurrent requests answered on each
+other's model, thinking level, word limits. The first app met it with a
+process-wide lock around every framework call, one card at a time (handoff from
+alsotrue-app, 2026-10-06).
+
+Now `settings` resolves through `get_current_settings()` on every read: the
+innermost `using_settings(...)` of the current asyncio context, else the base
+`setup()` installed. Every `Provide[DI.settings]` and every `SettingsAware.settings`
+read goes through it unchanged.
+
+    from dialectical_framework.settings_context import using_settings
+
+    with using_settings(base.model_copy(update={"ai_model": person_model})):
+        reply = await consultant.chat(text)      # this request, this model
+
+`create_task` / `gather` copy the context, so the framework's own fan-out (best-of-N
+draws, the coherence judge, the off-turn weave) runs on the settings of the turn
+that started it. Composes with `scope(sid)`; the two stay separate on purpose
+(`scope` is whose data, this is how to reason).
+
+TWO TIERS, as the code already treats them (see `Settings`):
+- read at call time, per request: `ai_model`, `reasoning_model`, everything read
+  through `SettingsAware.settings` (word limits, thinking level, the Advisor's
+  floors and caps, the audit switches);
+- read ONCE per process, from the base only: `graph_db_*` (the connection is a
+  Singleton), `llm_connect_timeout_s` (the provider is registered once),
+  `effect_log_dir` (installed in `setup`). A value for these inside
+  `using_settings` has no effect, by construction, not by accident.
+
+`container.settings.override(...)` RAISES: it would replace this provider with one
+fixed object and silently put the whole process back on a single settings slot.
+"""
+
+from __future__ import annotations
+
+import contextvars
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    from dialectical_framework.settings import Settings
+
+_base: Optional["Settings"] = None
+_current: contextvars.ContextVar[Optional["Settings"]] = contextvars.ContextVar(
+    "current_settings", default=None
+)
+
+
+def set_base_settings(settings: Settings) -> None:
+    """The process default, installed by `DialecticalReasoning.setup()`. A later
+    `setup()` replaces it, as a second container always replaced the first."""
+    global _base
+    _base = settings
+
+
+def get_base_settings() -> Settings:
+    """The process base. Raises when nothing called `setup()` — an unconfigured
+    process must fail loudly, not run on a default nobody chose."""
+    if _base is None:
+        raise RuntimeError(
+            "No settings installed: call DialecticalReasoning.setup(settings) "
+            "once per process before using the framework."
+        )
+    return _base
+
+
+def get_current_settings() -> Settings:
+    """The innermost `using_settings` of this context, else the base. The DI
+    container's `settings` provider calls this on every resolution."""
+    return _current.get() or get_base_settings()
+
+
+class _SettingsContextManager:
+    def __init__(self, settings: Settings) -> None:
+        self._settings = settings
+        self._token: Optional[contextvars.Token] = None
+
+    def __enter__(self) -> Settings:
+        self._token = _current.set(self._settings)
+        return self._settings
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        if self._token is not None:
+            _current.reset(self._token)
+
+
+def using_settings(settings: Settings) -> _SettingsContextManager:
+    """Run framework calls inside this context on `settings` (HOST LAYER).
+
+    Async-safe: each asyncio task sees only what was set in its own context;
+    tasks created inside inherit it; code outside sees the base. Nesting: the
+    innermost wins and the outer is restored on exit. An explicit
+    `use_brain(ai_model=...)` still wins over both. Build the value from the base
+    (`get_base_settings().model_copy(update=...)`) so per-request choices do not
+    drop the deployment's own values.
+    """
+    return _SettingsContextManager(settings)

{dialectical_framework-2.0.3 → dialectical_framework-2.0.5}/src/dialectical_framework/utils/edge_context.py

@@ -104,9 +104,42 @@ def build_edge_context(source_segment: WheelSegment, target_segment: WheelSegmen
     if target_t_minus:
         parts.append(f"A-: {target_t_minus[0].prompt_text}")
 
+    if _crosses_tensions(source_segment, target_segment):
+        parts.append(CROSS_TENSION_NOTE)
+
     return "\n".join(parts)
 
 
+#: Said whenever the two segments belong to DIFFERENT tensions — every edge of a
+#: wheel with two or more tensions. The labels above are relative ("A" is just the
+#: target), and at N >= 2 the writer read that "A" as T's own antithesis: on ten
+#: two-tension wheels a third of the staged Ac+ (28% / 35%, two generations) turned
+#: T's trap into T's OWN tension's strength instead of this target's, while a
+#: one-shot prompt carrying this sentence did so in 4% / 18%
+#: (`tests/e2e/probe_n2_one_shot_edge.py`, 2026-10-06). On a one-tension wheel the
+#: target IS the other side of T's tension, so nothing is said there.
+CROSS_TENSION_NOTE = (
+    "(T and A above come from TWO DIFFERENT tensions: do not read A as the other "
+    "side of T's own tension — a move that ends in T's own opposite has not "
+    "reached this A.)"
+)
+
+
+def _crosses_tensions(source_segment: WheelSegment, target_segment: WheelSegment) -> bool:
+    """True when the target is NOT the other side of the source's own tension.
+
+    By the statements, not the perspectives: two readings of one polarity are
+    different perspectives over the SAME tension, and their edge is not a
+    crossing. Unknown (a missing statement) reads as not crossing — the note is
+    an aid, and saying nothing is the old behaviour.
+    """
+    own_other = source_segment.opposite.t.get()
+    target_t = target_segment.t.get()
+    if not own_other or not target_t:
+        return False
+    return own_other[0].hash != target_t[0].hash
+
+
 def build_coarser_context(parents: list[CoarserTransformation]) -> Optional[str]:
     """
     Build hierarchical refinement context from coarser parent Transformations.