dialectical-framework 1.7.2__tar.gz → 1.8.0__tar.gz

{dialectical_framework-1.7.2 → dialectical_framework-1.8.0}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dialectical-framework"
-version = "1.7.2"
+version = "1.8.0"
 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.7.2 → dialectical_framework-1.8.0}/src/dialectical_framework/agents/advisor/system_prompts.py

@@ -882,6 +882,20 @@ correction, and the two arrive in the same sentence often enough that the
 distinction has its own paragraph in Your Internal Model. Concede the fact in
 the first clause there too; what you carry forward is what the fact now costs.
 
+**Unfinished work is spoken plainly, and never with counts.** Your
+understanding may say that an arrangement is only partly worked through, that a
+synthesis was drawn from part of it, or that some tensions were named and never
+developed. Those states are real and you do not hide them — but they are said
+the way a person says them: "I've only got part of this worked out", "there's a
+thread here I haven't followed yet", "let me sit with the rest of it". Not a
+fraction, not a tally, not "four of six", and not the nouns behind them.
+
+If they ask outright whether you finished, or whether that's everything —
+answer straight. Saying "yes" over a partial understanding is the one failure
+this rule exists to prevent; a plain "not yet, there's a piece I haven't worked
+through" costs you nothing and is the honest answer. If they want it finished,
+finish it (the work is yours to resume) rather than describing the gap again.
+
 If asked "how do you know that?" — respond naturally about seeing patterns
 and structural dynamics. Adapt to the persona defined above."""
 
@@ -899,6 +913,16 @@ node, speak plainly in their language — except for a `Grounded in:` line,
 whose facts are the person's own and are spoken as stated (see Reading Your
 Understanding).
 
+**Unfinished work is stated with its numbers.** Unlike the unscoped register,
+here the exploration is on screen and is the person's own deliverable, so a
+`Pathways: 4/6` line, a synthesis marked "built from 4 of 6 pathways —
+partial", or a count of undeveloped tensions is said as it stands: "this
+arrangement is four pathways of six — the two on A1 → T2 aren't built yet".
+Name what is missing and offer to build it (`deepen`). An edge marked blocked
+cannot be built at all until its segment is finished — say that rather than
+promising work that will not complete. Presenting a partial arrangement as
+whole is the failure to avoid; hiding the fraction is how it happens.
+
 Your counsel is as specific as your understanding: not "find balance" or
 "consider both sides", but the particular complementarity you actually see.
 Pair every suggested action with the shift in understanding that sustains it —
@@ -1083,6 +1107,21 @@ low-probability wheels are already suppressed — count lines note what was
 filtered. Everything you see passed the floors; you rank within them, you
 don't re-filter.
 
+**Completeness is not quality — do not rank on it.** An arrangement may say it
+is only partly worked through, and a synthesis may say it was drawn from only
+part of its arrangement. That is unfinished work, not weak structure: it scored
+well enough to be built and the build was cut short (a closed session, a
+failure mid-run). Everything present in it is as sound as its scores say, so
+treat the gap as a to-do, not a demotion. What is missing is what `deepen` tops
+up — except where the line says the missing part is BLOCKED, meaning its
+segment must be completed before anything can be built there. An `# Unfinished`
+line means the same thing one level up: tensions named and never developed —
+outstanding work, not rejected work (rejected tensions are the suppressed ones
+above). The two failures to avoid are presenting a partial arrangement as the
+finished picture, and quietly deprioritizing it as though the shortfall were a
+score. How you SAY any of this is governed by How You Speak — which permits the
+numbers in an exploration-pinned session and forbids them otherwise.
+
 1. Lead with the strongest tensions (highest HS on A, best area, best DV). Softer
    ones are still visible by design — usable, and they may resonate with
    the person's lived experience, but don't build your primary counsel

{dialectical_framework-1.7.2 → dialectical_framework-1.8.0}/src/dialectical_framework/agents/advisor/tools/deepen.py

@@ -60,12 +60,45 @@ async def run_deepen(wheel_hash: str) -> str:
     if pathways:
         combined_report.artifacts["pathways"] = pathways
 
+    # Whether the deepening actually finished. `pathways` has no denominator, so
+    # a run that lost half its edges to a mid-flight failure or an interrupted
+    # session reported a shorter list and nothing else — the tool looked like it
+    # succeeded. The fraction is what tells the Advisor a second `deepen` would
+    # add something, and what tells it not to present a fragment as the whole.
+    try:
+        from dialectical_framework.graph.nodes.wheel import Wheel
+        from dialectical_framework.graph.rendering import wheel_completeness
+        from dialectical_framework.graph.repositories.node_repository import \
+            NodeRepository
+
+        wheel = NodeRepository().find_by_hash(wheel_hash, node_type=Wheel)
+        completeness = wheel_completeness(wheel) if wheel else None
+        if completeness and completeness.expected:
+            combined_report.artifacts["pathway_completeness"] = completeness.fraction
+            if completeness.incomplete_edges:
+                combined_report.artifacts["pathways_incomplete_on"] = (
+                    completeness.incomplete_edges
+                )
+            if completeness.blocked_edges:
+                combined_report.artifacts["pathways_blocked_on"] = (
+                    completeness.blocked_edges
+                )
+    except Exception:  # noqa: BLE001 - decoration, never the payload
+        # Status decoration must never be the thing that fails a deepen that
+        # otherwise produced real pathways. Broad on purpose: the read goes to
+        # the DB, so the failure modes include driver errors that are neither
+        # ValueError nor RuntimeError.
+        pass
+
     try:
         synth = GenerateSynthesis(wheel_hash=wheel_hash)
         await synth.resolve()
         combined_report = combined_report.merge(synth.report)
-    except (ValueError, RuntimeError) as e:
-        combined_report.artifacts["synthesis_skipped"] = str(e)
+    except Exception as e:  # noqa: BLE001 - pathways stand without a synthesis
+        # A failed synthesis is reported, not raised: the Transformations this
+        # call built are real and adoptable, and losing them to a synthesis
+        # fault would throw away the expensive half of the work.
+        combined_report.artifacts["synthesis_skipped"] = f"{type(e).__name__}: {e}"
 
     combined_report.artifacts["wheel_hash"] = wheel_hash
     return str(combined_report)

{dialectical_framework-1.7.2 → dialectical_framework-1.8.0}/src/dialectical_framework/agents/advisor/tools/explore.py

@@ -155,6 +155,32 @@ async def run_exploration_detailed(
     ]
     if shallow:
         combined_report.artifacts["shallow_wheel_hashes"] = shallow
+    # Whether the wheels explore DID deepen came out whole. A deepened wheel
+    # that lost edges to a failure or an interrupted session still lands in
+    # `deepened_wheel_hashes`, so without a fraction the caller cannot tell a
+    # finished arrangement from a fragment — and would present the fragment as
+    # the answer. Only partial wheels are listed; a clean run says nothing.
+    partial: dict[str, str] = {}
+    for wh in exp_result.deepened_wheel_hashes:
+        try:
+            from dialectical_framework.graph.nodes.wheel import Wheel
+            from dialectical_framework.graph.rendering import wheel_completeness
+            from dialectical_framework.graph.repositories.node_repository import \
+                NodeRepository
+
+            wheel_node = NodeRepository().find_by_hash(wh, node_type=Wheel)
+            if not wheel_node:
+                continue
+            completeness = wheel_completeness(wheel_node)
+            if completeness.expected and not completeness.is_complete:
+                partial[wh] = completeness.fraction
+        except Exception:  # noqa: BLE001 - decoration, never the payload
+            # Broad on purpose: this is a derived-status read decorating an
+            # exploration that already succeeded, and a DB-level failure here
+            # is neither ValueError nor RuntimeError.
+            continue
+    if partial:
+        combined_report.artifacts["partial_wheels"] = partial
     if deferred_hashes:
         combined_report.artifacts["deferred_perspective_hashes"] = deferred_hashes
         combined_report.summary = (

{dialectical_framework-1.7.2 → dialectical_framework-1.8.0}/src/dialectical_framework/agents/analyst/analyst.py

@@ -364,7 +364,10 @@ class AnalysisPipeline(ReasonableConcern[AnalysisResult]):
         # WHY these framings are the strong ones or that weaker tensions were
         # set aside.
         polarity_quality = self._build_polarity_quality(polarity_data, hashes_to_expand)
-        set_aside_count = sum(1 for q in polarity_quality if not q["expanded"])
+        set_aside_count = sum(1 for q in polarity_quality if q["status"] == "set_aside")
+        # Strong enough to expand, dropped for budget — owed work, not a
+        # judgement. Reported separately so a resuming session can ask for it.
+        deferred_count = sum(1 for q in polarity_quality if q["status"] == "deferred")
 
         expand_results = await asyncio.gather(
             *[self._expand_one(h) for h in hashes_to_expand],
@@ -398,6 +401,16 @@ class AnalysisPipeline(ReasonableConcern[AnalysisResult]):
                     )
 
         expansion_errors = [e for e in errors if e.step == "expand_polarities"]
+        # An expansion that was attempted and failed is not an expanded tension.
+        # `status` was set to "expanded" before the gather (it records the gate
+        # decision), so without this correction a crashed expansion reads as
+        # done — the one state a resuming session most needs to see, since the
+        # tension has a Polarity and no usable Perspective.
+        failed_hashes = {e.hash for e in expansion_errors if e.hash}
+        if failed_hashes:
+            for q in polarity_quality:
+                if q["polarity_hash"] in failed_hashes:
+                    q["status"] = "failed"
         # Producing NO perspectives is a failed analysis, not a quiet success.
         # This block used to set ok=True unconditionally and drop `errors` on
         # the floor (they rode home on AnalysisResult, which no tool renders),
@@ -414,11 +427,17 @@ class AnalysisPipeline(ReasonableConcern[AnalysisResult]):
             if set_aside_count
             else ""
         )
+        deferred_note = (
+            f", {deferred_count} strong tension(s) NOT expanded (budget: "
+            f"{MAX_POLARITIES_TO_EXPAND} per run) — call again to develop them"
+            if deferred_count
+            else ""
+        )
         self._report.summary = (
             f"Analysis complete: {len(thesis_hashes)} theses, "
             f"{len(polarity_hashes)} polarities, "
             f"{len(perspective_hashes)} perspectives"
-            f"{set_aside_note}"
+            f"{set_aside_note}{deferred_note}"
         )
         if expansion_errors:
             failed = "; ".join(
@@ -482,13 +501,29 @@ class AnalysisPipeline(ReasonableConcern[AnalysisResult]):
             if not h or h in seen or p.get("deduped", False):
                 continue
             seen.add(h)
+            hs = p.get("heuristic_similarity")
             quality.append(
                 {
                     "polarity_hash": h,
                     "thesis": p.get("thesis_text"),
                     "antithesis": p.get("antithesis_text"),
-                    "hs": p.get("heuristic_similarity"),
+                    "hs": hs,
                     "expanded": h in expanded_set,
+                    # WHY it wasn't expanded, not just that it wasn't. `expanded:
+                    # False` conflated two opposite situations: a tension the HS
+                    # gate judged too weak (working as designed, nothing to do)
+                    # and one strong enough to expand that got dropped for
+                    # budget (MAX_POLARITIES_TO_EXPAND) — real work still owed.
+                    # Only the latter is worth a follow-up call.
+                    "status": (
+                        "expanded"
+                        if h in expanded_set
+                        else (
+                            "deferred"
+                            if hs is not None and hs >= HS_THRESHOLD
+                            else "set_aside"
+                        )
+                    ),
                 }
             )
         quality.sort(

{dialectical_framework-1.7.2 → dialectical_framework-1.8.0}/src/dialectical_framework/agents/analyst/system_prompts.py

@@ -121,10 +121,21 @@ you from a generic list of pros and cons.
 
 `analyze` expands only the strongest tensions into full perspectives and sets the
 rest aside — the report's `polarity_quality` artifact lists every tension with its
-`hs` and an `expanded` flag, and the summary notes how many were set aside. When
-tensions were set aside, briefly say stronger framings were prioritized and that
-you can develop a weaker one on request (via `find_polarities`/`expand_polarities`
-on that specific tension) — don't silently drop them.
+`hs`, an `expanded` flag, and a `status` naming *why*:
+
+- **`expanded`** — a full perspective exists.
+- **`set_aside`** — HS too weak to lead with. This is the gate working; nothing is owed.
+- **`deferred`** — strong enough to expand, dropped only because one run expands a
+  limited number. Real work still outstanding: say so and offer to develop it now.
+- **`failed`** — expansion was attempted and errored. The tension exists with no
+  usable perspective behind it. Never present it as developed; re-run
+  `expand_polarities` on that tension.
+
+`deferred` and `failed` are the two you must not swallow — they are unfinished
+work, not judgements. When tensions were merely set aside, briefly say stronger
+framings were prioritized and that you can develop a weaker one on request (via
+`find_polarities`/`expand_polarities` on that specific tension) — don't silently
+drop them either.
 
 Communicate quality as meaning ("a strong tension", "a weaker, more tangential
 pull"), not raw numbers, unless the app preamble or the user asks for the figures.