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

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

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

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

@@ -251,8 +251,8 @@ class ReSideCompletionDto(BaseModel):
     # 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
+    # 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

{dialectical_framework-2.0.4 → dialectical_framework-2.0.6}/src/dialectical_framework/concerns/transformation_sketch.py

@@ -145,24 +145,26 @@ 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: with the text
-    alone a valid Ac- (lands in A-, is the action degenerated, does not start
-    from A+) came back in 30% of drafts and a valid Re- in 26%, because "the
+    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 56% / 62% (paired +26 / +36, both
-    clearing noise), S- unchanged within noise (`tests/e2e/probe_transformation_sketch.py`,
+    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 three blind theory reviewers agreed with on 51/52 clear
-    cases; the app's stricter auditor had read 22/18% -> 60/58%). A host may
+    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 to watch, OPEN: the ends rose and the makeup reads dipped
-    ("Re- is the reflection itself" 94% -> 88% here, within noise; the first
-    app's pill measured 98% -> 80% in its own voice). A line written to land
-    on A+ -> T- can stop reading as the reflection overdone. If a host's
-    makeup read keeps falling, that is a trade to measure on this probe, not
-    a reason to drop the fields by eye.
+    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

{dialectical_framework-2.0.4 → dialectical_framework-2.0.6}/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.4 → dialectical_framework-2.0.6}/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.6/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)