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

dialectical_framework-1.6.2/PKG-INFO

@@ -0,0 +1,178 @@
+Metadata-Version: 2.3
+Name: dialectical-framework
+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
+Author: Evaldas Taroza
+Author-email: evaldas@dialexity.com
+Requires-Python: >=3.11,<4.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Framework :: Pydantic
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Education
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Human Machine Interfaces
+Classifier: Topic :: Sociology
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing :: Linguistic
+Requires-Dist: boto3 (>=1.43.4,<2.0.0)
+Requires-Dist: broadcaster (>=0.3.1,<0.4.0)
+Requires-Dist: dependency-injector (>=4.48.2,<5.0.0)
+Requires-Dist: gqlalchemy (>=1.8.0,<2.0.0)
+Requires-Dist: langfuse (>=4.5.1,<5.0.0)
+Requires-Dist: mirascope[anthropic,openai,ops] (>=2.5.0,<3.0.0)
+Requires-Dist: python-dotenv (>=1.2.1,<2.0.0)
+Requires-Dist: tabulate (>=0.9.0,<0.10.0)
+Project-URL: Homepage, https://github.com/dialexity/dialectical-framework
+Project-URL: Repository, https://github.com/dialexity/dialectical-framework
+Description-Content-Type: text/markdown
+
+# Dialectical Framework
+
+**Make an LLM reason in oppositions, not averages.**
+
+Ask a model a hard question and it tends to collapse the tension into one confident answer — or hedge with a bland "on one hand… on the other." This framework does neither. For every thesis it generates a genuine antithesis, maps precisely where each side overreaches (T-, A-) and where it constructively balances the other (T+, A+), and drives the pair toward a **synthesis** — not a compromise, but a new quality that emerges from their circular causality and that neither pole held alone.
+
+The reasoning lives in a graph. Every move — surfacing a thesis, finding its opposition, developing its four aspects, arranging them into a **Wheel** — writes semantic, rule-validated nodes and edges into a graph database. The graph **is** the state: a persistent, compounding map of how a domain's tensions resolve, that any application can query, visualize, or build on.
+
+And the synthesis is *earned*, not asserted. Where "think step by step" leaves rigor to chance, formal generative rules define what counts as valid: exactly one antithesis per thesis, modality kept in balance, and positive synthesis (S+) only when T-'s excess transforms into A+ and A-'s into T+. The structure enforces a discipline the prompt alone can't.
+
+## Learn More
+- [Structured Dialectics](https://dialexity.com/blog/structured-dialectics-consolidated-manuscript/) - the theory
+- [Dialectical Wheels for Systems Optimization](https://dialexity.com/blog/dialectical-wheels-for-systems-optimization/)
+- [Dialectical Ethics](https://dialexity.com/blog/dialectical-ethics/)
+
+
+## How It Works
+
+1. **Input** — text, URLs, or raw ideas from any domain
+2. **Analysis** — extract the theses, find each one's true antithesis, develop the four aspects (T+, T-, A+, A-) that say where each side helps and where it overreaches
+3. **Graph curation** — commit every insight as content-addressed, rule-validated nodes and edges — nothing is stored until it holds up
+4. **Exploration** — combine perspectives into Cycles, arrange them into Wheels, and trace the Transformations whose circular causality yields synthesis
+
+Each pass leaves the graph richer than it found it: new tensions enter an existing web of validated reasoning, so understanding compounds instead of resetting every prompt.
+
+## Architecture
+
+```
+Host Application (Chainlit, API, CLI)
+        │
+        ▼
+    Agent: Analyst · Explorer · Advisor (LLM + tools)
+        │
+        ▼
+    Graph Database (Memgraph / Neo4j)
+```
+
+An **agent** is the entry point — a thin LLM orchestrator that manages a conversation with tools that read and write the graph. There are three (Analyst, Explorer, Advisor); each owns a tool set and a domain-neutral reasoning prompt. The host app controls persona (via the app preamble) and scope identity (`sid`); the framework handles reasoning and graph curation. See [docs/agents.md](docs/agents.md).
+
+### Docs
+- [Agents: Analyst, Explorer, Advisor](docs/agents.md) — the building blocks, their tools, and the UX to build around them
+- [Graph Data Model](docs/graph.md)
+- [Scoring & Metrics](docs/scoring.md)
+
+## Why a Reasoning Graph
+
+Most AI systems treat knowledge as flat context — dump text into the prompt and hope the LLM figures out the structure. The dialectical framework builds a **persistent reasoning graph** where the structure itself encodes how to think about a domain:
+
+- **Oppositions are explicit.** The LLM doesn't rediscover the tensions on every call — they persist as typed T/A pairs, so reasoning starts from a mapped conflict instead of a blank page.
+- **Transformations encode causality.** Edges don't just connect — they show how one position's failure becomes another's strength. This is the circular causality that drives synthesis.
+- **Quality is measurable.** Complementarity, modality balance, area metrics tell the LLM which reasoning paths are well-developed and which are thin — no guessing about confidence.
+- **Knowledge compounds.** Each new perspective enters an existing graph of validated reasoning. The LLM builds on prior synthesis rather than re-deriving from scratch.
+
+The result: an LLM with this graph in context doesn't just have facts about a topic — it has the intellectual terrain mapped. What opposes what, where balance was achieved, what assumptions remain untested, and where synthesis is possible.
+
+This is the [LLM Wiki](https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f) pattern realized as a semantic graph rather than a pile of markdown files — knowledge that is structured, rule-validated, and queryable by reasoning topology.
+
+| Simple | Detailed |
+|--------|----------|
+| ![Wheel](https://raw.githubusercontent.com/dialexity/dialectical-framework/main/docs/wheel-scheme.png) | ![Wheel](https://raw.githubusercontent.com/dialexity/dialectical-framework/main/docs/wheel-scheme2.png) |
+
+## Core Graph Structure
+
+It's all one graph. **Statements** are the atoms; typed edges carry the dialectical relationships — opposition, complementarity, transformation — and each structure below composes the ones above it into progressively richer reasoning, culminating in the **Dialectical Wheel**.
+
+| Structure | Role |
+|-----------|------|
+| **Statement** | Atomic unit of meaning — a thesis, position, or claim |
+| **Polarity** | A single T↔A tension (thesis vs. antithesis); reusable across perspectives |
+| **Perspective** | A full tetrad — a Polarity developed with its four aspects (T+, T-, A+, A-) |
+| **Nexus** | A working set of Perspectives grouped for exploration |
+| **Cycle** | An ordered sequence of Perspectives — which tension drives which |
+| **Wheel** | A concrete circular arrangement of a Cycle, with the edges between components |
+| **Transition** | A directed edge between two components — one step around the Wheel |
+| **Transformation** | The Action-Reflection paths on an edge that turn one pole's excess into the other's strength |
+| **Synthesis** | The emergent S+/S- arising from the whole Wheel's circular causality |
+
+Picture the Wheel as a pizza sliced into segments: each **segment** bundles a component with its plus and minus (e.g. T, T+, T-), a **Perspective** joins a thesis segment with the antithesis segment directly across from it, and **Transitions** are the arrows running segment to segment around the rim.
+
+## Integration
+
+Wherever the answer is a tension rather than a fact, this drops in as the reasoning engine: decision support that weighs both sides, systems thinking, mediation between opposed positions, ethical modeling. You wire it into your app through three conversational agents — the main building blocks:
+
+- **Analyst** — turns raw material into structured tensions, up to grouping them into a Nexus (Case-scoped).
+- **Explorer** — takes one Nexus and works out its causal pathways and synthesis (Nexus-scoped).
+- **Advisor** — runs the whole machine silently and returns pure counsel, with no framework vocabulary exposed (Case-scoped).
+
+Analyst + Explorer are the structure-forward "graph navigator" experience; the Advisor is a chat-only product over the same graph. See [docs/agents.md](docs/agents.md) for full specs, tool lists, and the UX to build around each.
+
+```python
+from dialectical_framework.dialectical_reasoning import DialecticalReasoning
+from dialectical_framework.settings import Settings
+from dialectical_framework.graph.nodes.case import Case
+from dialectical_framework.graph.scope_context import scope
+from dialectical_framework.agents.advisor.advisor import Advisor
+
+# Initialize once
+DialecticalReasoning.setup(Settings.from_env())
+
+# A Case owns the scope id (sid); all graph writes are sid-scoped.
+case = Case(); case.commit()
+
+with scope(case.sid):
+    advisor = Advisor(app_preamble="You are a systems thinking coach...")
+    async for event in advisor.chat_stream("Analyze the tension between growth and sustainability"):
+        # ThinkingDelta, TextDelta, ToolStart, ToolResult, ResponseComplete
+        handle(event)
+```
+
+## Setup
+
+### Requirements
+
+- Python 3.11+
+- Memgraph or Neo4j
+- An LLM provider (OpenAI, Anthropic, or Bedrock via a custom Mirascope provider)
+
+### Install
+
+```bash
+poetry install
+cp .env.example .env   # then fill in the values (see .env.example for details)
+```
+
+### Run Tests
+
+```bash
+poetry run pytest              # All tests (LLM mocked)
+poetry run pytest -m llm       # Only LLM-path tests (mocked)
+poetry run pytest --real-llm   # Hit real LLM provider
+```
+
+## Built With
+
+- [Mirascope](https://mirascope.com/) — LLM abstraction
+- [GQLAlchemy](https://memgraph.com/docs/gqlalchemy) — Graph ORM
+- [dependency-injector](https://python-dependency-injector.ets-labs.org/) — DI container

dialectical_framework-1.6.2/README.md

@@ -0,0 +1,137 @@
+# Dialectical Framework
+
+**Make an LLM reason in oppositions, not averages.**
+
+Ask a model a hard question and it tends to collapse the tension into one confident answer — or hedge with a bland "on one hand… on the other." This framework does neither. For every thesis it generates a genuine antithesis, maps precisely where each side overreaches (T-, A-) and where it constructively balances the other (T+, A+), and drives the pair toward a **synthesis** — not a compromise, but a new quality that emerges from their circular causality and that neither pole held alone.
+
+The reasoning lives in a graph. Every move — surfacing a thesis, finding its opposition, developing its four aspects, arranging them into a **Wheel** — writes semantic, rule-validated nodes and edges into a graph database. The graph **is** the state: a persistent, compounding map of how a domain's tensions resolve, that any application can query, visualize, or build on.
+
+And the synthesis is *earned*, not asserted. Where "think step by step" leaves rigor to chance, formal generative rules define what counts as valid: exactly one antithesis per thesis, modality kept in balance, and positive synthesis (S+) only when T-'s excess transforms into A+ and A-'s into T+. The structure enforces a discipline the prompt alone can't.
+
+## Learn More
+- [Structured Dialectics](https://dialexity.com/blog/structured-dialectics-consolidated-manuscript/) - the theory
+- [Dialectical Wheels for Systems Optimization](https://dialexity.com/blog/dialectical-wheels-for-systems-optimization/)
+- [Dialectical Ethics](https://dialexity.com/blog/dialectical-ethics/)
+
+
+## How It Works
+
+1. **Input** — text, URLs, or raw ideas from any domain
+2. **Analysis** — extract the theses, find each one's true antithesis, develop the four aspects (T+, T-, A+, A-) that say where each side helps and where it overreaches
+3. **Graph curation** — commit every insight as content-addressed, rule-validated nodes and edges — nothing is stored until it holds up
+4. **Exploration** — combine perspectives into Cycles, arrange them into Wheels, and trace the Transformations whose circular causality yields synthesis
+
+Each pass leaves the graph richer than it found it: new tensions enter an existing web of validated reasoning, so understanding compounds instead of resetting every prompt.
+
+## Architecture
+
+```
+Host Application (Chainlit, API, CLI)
+        │
+        ▼
+    Agent: Analyst · Explorer · Advisor (LLM + tools)
+        │
+        ▼
+    Graph Database (Memgraph / Neo4j)
+```
+
+An **agent** is the entry point — a thin LLM orchestrator that manages a conversation with tools that read and write the graph. There are three (Analyst, Explorer, Advisor); each owns a tool set and a domain-neutral reasoning prompt. The host app controls persona (via the app preamble) and scope identity (`sid`); the framework handles reasoning and graph curation. See [docs/agents.md](docs/agents.md).
+
+### Docs
+- [Agents: Analyst, Explorer, Advisor](docs/agents.md) — the building blocks, their tools, and the UX to build around them
+- [Graph Data Model](docs/graph.md)
+- [Scoring & Metrics](docs/scoring.md)
+
+## Why a Reasoning Graph
+
+Most AI systems treat knowledge as flat context — dump text into the prompt and hope the LLM figures out the structure. The dialectical framework builds a **persistent reasoning graph** where the structure itself encodes how to think about a domain:
+
+- **Oppositions are explicit.** The LLM doesn't rediscover the tensions on every call — they persist as typed T/A pairs, so reasoning starts from a mapped conflict instead of a blank page.
+- **Transformations encode causality.** Edges don't just connect — they show how one position's failure becomes another's strength. This is the circular causality that drives synthesis.
+- **Quality is measurable.** Complementarity, modality balance, area metrics tell the LLM which reasoning paths are well-developed and which are thin — no guessing about confidence.
+- **Knowledge compounds.** Each new perspective enters an existing graph of validated reasoning. The LLM builds on prior synthesis rather than re-deriving from scratch.
+
+The result: an LLM with this graph in context doesn't just have facts about a topic — it has the intellectual terrain mapped. What opposes what, where balance was achieved, what assumptions remain untested, and where synthesis is possible.
+
+This is the [LLM Wiki](https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f) pattern realized as a semantic graph rather than a pile of markdown files — knowledge that is structured, rule-validated, and queryable by reasoning topology.
+
+| Simple | Detailed |
+|--------|----------|
+| ![Wheel](https://raw.githubusercontent.com/dialexity/dialectical-framework/main/docs/wheel-scheme.png) | ![Wheel](https://raw.githubusercontent.com/dialexity/dialectical-framework/main/docs/wheel-scheme2.png) |
+
+## Core Graph Structure
+
+It's all one graph. **Statements** are the atoms; typed edges carry the dialectical relationships — opposition, complementarity, transformation — and each structure below composes the ones above it into progressively richer reasoning, culminating in the **Dialectical Wheel**.
+
+| Structure | Role |
+|-----------|------|
+| **Statement** | Atomic unit of meaning — a thesis, position, or claim |
+| **Polarity** | A single T↔A tension (thesis vs. antithesis); reusable across perspectives |
+| **Perspective** | A full tetrad — a Polarity developed with its four aspects (T+, T-, A+, A-) |
+| **Nexus** | A working set of Perspectives grouped for exploration |
+| **Cycle** | An ordered sequence of Perspectives — which tension drives which |
+| **Wheel** | A concrete circular arrangement of a Cycle, with the edges between components |
+| **Transition** | A directed edge between two components — one step around the Wheel |
+| **Transformation** | The Action-Reflection paths on an edge that turn one pole's excess into the other's strength |
+| **Synthesis** | The emergent S+/S- arising from the whole Wheel's circular causality |
+
+Picture the Wheel as a pizza sliced into segments: each **segment** bundles a component with its plus and minus (e.g. T, T+, T-), a **Perspective** joins a thesis segment with the antithesis segment directly across from it, and **Transitions** are the arrows running segment to segment around the rim.
+
+## Integration
+
+Wherever the answer is a tension rather than a fact, this drops in as the reasoning engine: decision support that weighs both sides, systems thinking, mediation between opposed positions, ethical modeling. You wire it into your app through three conversational agents — the main building blocks:
+
+- **Analyst** — turns raw material into structured tensions, up to grouping them into a Nexus (Case-scoped).
+- **Explorer** — takes one Nexus and works out its causal pathways and synthesis (Nexus-scoped).
+- **Advisor** — runs the whole machine silently and returns pure counsel, with no framework vocabulary exposed (Case-scoped).
+
+Analyst + Explorer are the structure-forward "graph navigator" experience; the Advisor is a chat-only product over the same graph. See [docs/agents.md](docs/agents.md) for full specs, tool lists, and the UX to build around each.
+
+```python
+from dialectical_framework.dialectical_reasoning import DialecticalReasoning
+from dialectical_framework.settings import Settings
+from dialectical_framework.graph.nodes.case import Case
+from dialectical_framework.graph.scope_context import scope
+from dialectical_framework.agents.advisor.advisor import Advisor
+
+# Initialize once
+DialecticalReasoning.setup(Settings.from_env())
+
+# A Case owns the scope id (sid); all graph writes are sid-scoped.
+case = Case(); case.commit()
+
+with scope(case.sid):
+    advisor = Advisor(app_preamble="You are a systems thinking coach...")
+    async for event in advisor.chat_stream("Analyze the tension between growth and sustainability"):
+        # ThinkingDelta, TextDelta, ToolStart, ToolResult, ResponseComplete
+        handle(event)
+```
+
+## Setup
+
+### Requirements
+
+- Python 3.11+
+- Memgraph or Neo4j
+- An LLM provider (OpenAI, Anthropic, or Bedrock via a custom Mirascope provider)
+
+### Install
+
+```bash
+poetry install
+cp .env.example .env   # then fill in the values (see .env.example for details)
+```
+
+### Run Tests
+
+```bash
+poetry run pytest              # All tests (LLM mocked)
+poetry run pytest -m llm       # Only LLM-path tests (mocked)
+poetry run pytest --real-llm   # Hit real LLM provider
+```
+
+## Built With
+
+- [Mirascope](https://mirascope.com/) — LLM abstraction
+- [GQLAlchemy](https://memgraph.com/docs/gqlalchemy) — Graph ORM
+- [dependency-injector](https://python-dependency-injector.ets-labs.org/) — DI container

{dialectical_framework-1.6.0 → dialectical_framework-1.6.2}/pyproject.toml

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

@@ -136,11 +136,13 @@ Seven tools. Use silently — never mention them.
 
 - `ingest` — Processes raw material (text, files, transcripts) through
   dialectical analysis: extracts theses, finds oppositions, builds full
-  perspectives with aspects. Use when raw material needs analysis and you
-  don't yet see the tensions — compose the `text` parameter from what they've
-  shared. Do NOT ingest greetings or small talk. When pre-loaded sources exist
-  (shown in the dump under Sources), call ingest with just an `intent` to
-  extract tensions from them without new text.
+  perspectives with aspects. Use for open-ended material where no single
+  position is yet articulated and the tensions must be discovered — compose
+  the `text` parameter from what they've shared. When the person has already
+  named a clear position (or an explicit either/or), prefer `anchor` — it is
+  more reliable than extraction. Do NOT ingest greetings or small talk. When
+  pre-loaded sources exist (shown in the dump under Sources), call ingest with
+  just an `intent` to extract tensions from them without new text.
 
 - `anchor` — Plants a specific tension from the conversation. More precise
   than ingest; use when you can see at least the person's position. Two modes:
@@ -215,6 +217,13 @@ should reflect what resonates — retract what doesn't.
 4. `explore` → respond with specific paired pathways
 5. Continue with full depth, offer integration vision when they're ready
 
+**When a tool surfaces no tensions:** If `ingest` returns nothing (no
+perspectives in its result), the material resisted automatic extraction — this
+is a signal to `anchor` directly, not to fall back to unstructured discussion.
+Name the position you heard and the force that opposes it, and `anchor` that
+tension before responding. Only proceed on your own judgement if you genuinely
+cannot identify any opposition in what they've shared.
+
 ## What You Must Never Do
 
 - Reveal tools or internal processes

{dialectical_framework-1.6.0 → dialectical_framework-1.6.2}/src/dialectical_framework/agents/analyst/analyst.py

@@ -261,7 +261,11 @@ class AnalysisPipeline(ReasonableConcern[AnalysisResult]):
 
                 if not thesis_hashes:
                     self._report.ok = True
-                    self._report.summary = "No theses found"
+                    self._report.summary = (
+                        "No tensions extracted from this material. Anchor an "
+                        "explicit position (and its opposition, if visible) "
+                        "instead of ingesting."
+                    )
                     return AnalysisResult(
                         ideas_hash=ideas_hash, errors=errors, reports=reports
                     )

{dialectical_framework-1.6.0 → dialectical_framework-1.6.2}/src/dialectical_framework/agents/analyst/skills/anchor_theses.py

@@ -21,6 +21,7 @@ from pydantic import Field
 from dialectical_framework.agents.reasonable_concern import ReasonableConcern
 from dialectical_framework.concerns.statement_classification import (
     ClassificationResult, StatementClassification)
+from dialectical_framework.concerns.statement_headline import StatementHeadline
 from dialectical_framework.enums.di import DI
 from dialectical_framework.graph.nodes.ideas import Ideas
 from dialectical_framework.graph.nodes.rationale import Rationale
@@ -83,7 +84,11 @@ class AnchorTheses(ReasonableConcern[Optional[Ideas]]):
         statements: list[str],
         text: str = "",
     ) -> list[Statement]:
+        # Condense in parallel with classification. The agent may hand this skill
+        # verbose prose (there is no extraction step to clamp length), so the
+        # stored text becomes a headline while classification reads the full text.
         classifiers = [StatementClassification() for _ in statements]
+        headliners = [StatementHeadline() for _ in statements]
         tasks = [
             classifier.resolve(
                 statement=stmt,
@@ -92,25 +97,35 @@ class AnchorTheses(ReasonableConcern[Optional[Ideas]]):
             )
             for classifier, stmt in zip(classifiers, statements)
         ]
+        headline_tasks = [
+            headliner.resolve(statement=stmt, text=text)
+            for headliner, stmt in zip(headliners, statements)
+        ]
 
         results: list[ClassificationResult] = await asyncio.gather(*tasks)
+        headlines: list[str] = await asyncio.gather(*headline_tasks)
 
         components: list[Statement] = []
-        for classifier, result in zip(classifiers, results):
-            component = self._create_component(result)
+        for classifier, headliner, result, headline in zip(
+            classifiers, headliners, results, headlines
+        ):
+            component = self._create_component(result, headline)
             components.append(component)
             self._report = self._report.merge(classifier.report)
+            self._report = self._report.merge(headliner.report)
 
         return components
 
-    def _create_component(self, result: ClassificationResult) -> Statement:
-        component = Statement(text=result.statement, meaning=result.meaning)
+    def _create_component(
+        self, result: ClassificationResult, headline: str
+    ) -> Statement:
+        component = Statement(text=headline, meaning=result.meaning)
         component.commit()
 
         classification_label = "SIMPLE" if result.is_simple else "COMPLEX"
         self._report.node_created(
             component,
-            patch={"meaning": result.meaning, "text": result.statement},
+            patch={"meaning": result.meaning, "text": headline},
             meta={"classification": classification_label},
         )
 

{dialectical_framework-1.6.0 → dialectical_framework-1.6.2}/src/dialectical_framework/agents/analyst/skills/find_polarities.py

@@ -178,6 +178,7 @@ class FindPolarities(ReasonableConcern[Optional[Ideas]]):
                 vocabulary=dedup_vocab,
                 text=input_text,
             )
+            self._report = self._report.merge(deduplicator.report)
 
             # Reconnect OPPOSITE_OF: thesis -> DB version for replacements
             self._reconnect_oppositions(results, dedup_result)

{dialectical_framework-1.6.0 → dialectical_framework-1.6.2}/src/dialectical_framework/agents/analyst/skills/introduce_polarity.py

@@ -18,6 +18,7 @@ Usage:
 
 from __future__ import annotations
 
+import asyncio
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Annotated, Optional
 
@@ -26,17 +27,18 @@ from mirascope import llm
 from pydantic import Field
 
 from dialectical_framework.agents.reasonable_concern import ReasonableConcern
-from dialectical_framework.enums.di import DI
 from dialectical_framework.concerns.antithesis_classification import \
     AntithesisClassification
 from dialectical_framework.concerns.statement_classification import \
     StatementClassification
+from dialectical_framework.concerns.statement_headline import StatementHeadline
+from dialectical_framework.enums.di import DI
 from dialectical_framework.graph.estimation_manager import EstimationManager
-from dialectical_framework.graph.nodes.estimation import (
-    ArousalEstimation, ModeEstimation)
-from dialectical_framework.graph.nodes.statement import Statement
+from dialectical_framework.graph.nodes.estimation import (ArousalEstimation,
+                                                          ModeEstimation)
 from dialectical_framework.graph.nodes.polarity import Polarity
 from dialectical_framework.graph.nodes.rationale import Rationale
+from dialectical_framework.graph.nodes.statement import Statement
 from dialectical_framework.graph.repositories.input_repository import \
     InputRepository
 from dialectical_framework.graph.repositories.polarity_repository import \
@@ -117,12 +119,19 @@ class IntroducePolarity(ReasonableConcern[IntroducePolarityResult]):
             primary_polarity.commit()
             self._report.node_created(primary_polarity)
             self._report.relationship_created(
-                primary_polarity.t, thesis_stmt, primary_polarity,
+                primary_polarity.t,
+                thesis_stmt,
+                primary_polarity,
                 patch={"heuristic_similarity": 1.0, "alias": "T"},
             )
             self._report.relationship_created(
-                primary_polarity.a, antithesis_stmt, primary_polarity,
-                patch={"heuristic_similarity": classification.heuristic_similarity, "alias": "A"},
+                primary_polarity.a,
+                antithesis_stmt,
+                primary_polarity,
+                patch={
+                    "heuristic_similarity": classification.heuristic_similarity,
+                    "alias": "A",
+                },
             )
             self._report.artifacts["primary_polarity_source"] = "created"
 
@@ -135,9 +144,13 @@ class IntroducePolarity(ReasonableConcern[IntroducePolarityResult]):
             antithesis_stmt, ArousalEstimation, classification.arousal_value
         )
         if mode_est:
-            self._report.node_updated(mode_est, patch={"value": classification.mode_value})
+            self._report.node_updated(
+                mode_est, patch={"value": classification.mode_value}
+            )
         if arousal_est:
-            self._report.node_updated(arousal_est, patch={"value": classification.arousal_value})
+            self._report.node_updated(
+                arousal_est, patch={"value": classification.arousal_value}
+            )
 
         # Build result
         result = IntroducePolarityResult(
@@ -166,12 +179,23 @@ class IntroducePolarity(ReasonableConcern[IntroducePolarityResult]):
         return result
 
     async def _resolve_statement(self, text: str, context: str) -> Statement:
-        """Classify and commit a Statement. Commit is an upsert — same text reuses existing node."""
+        """Classify and commit a Statement. Commit is an upsert — same text reuses existing node.
+
+        The agent may pass verbose prose (the anchor path has no extraction step
+        to clamp length), so condense to a headline in parallel with
+        classification. Classification reads the full text for richer taxonomy
+        anchoring; only the stored ``text`` becomes the headline.
+        """
         classifier = StatementClassification()
-        result = await classifier.resolve(statement=text, text=context)
+        headliner = StatementHeadline()
+        result, headline = await asyncio.gather(
+            classifier.resolve(statement=text, text=context),
+            headliner.resolve(statement=text, text=context),
+        )
         self._report = self._report.merge(classifier.report)
+        self._report = self._report.merge(headliner.report)
 
-        stmt = Statement(text=result.statement, meaning=result.meaning)
+        stmt = Statement(text=headline, meaning=result.meaning)
         stmt.commit()
         self._report.node_created(stmt)
 
@@ -207,7 +231,9 @@ class IntroducePolarity(ReasonableConcern[IntroducePolarityResult]):
 async def introduce_polarity(
     thesis: Annotated[str, Field(description="The thesis statement text")],
     antithesis: Annotated[str, Field(description="The antithesis statement text")],
-    text: Annotated[str, Field(description="Additional context for classification")] = "",
+    text: Annotated[
+        str, Field(description="Additional context for classification")
+    ] = "",
 ) -> str:
     """Introduce a known thesis-antithesis tension directly as a Polarity. Classifies both statements, creates the Polarity node (T-A pair) with HS score. Use when the tension is already clear from conversation rather than needing extraction from source material."""
     concern = IntroducePolarity(thesis=thesis, antithesis=antithesis, text=text)

{dialectical_framework-1.6.0 → dialectical_framework-1.6.2}/src/dialectical_framework/agents/analyst/skills/surface_theses.py

@@ -157,6 +157,7 @@ class SurfaceTheses(ReasonableConcern[Optional[Ideas]]):
                 vocabulary=vocab,
                 text=input_text,
             )
+            self._report = self._report.merge(deduplicator.report)
             deleted_count = dedup_result.deleted_count
             deduped = dedup_result.components
         else:

{dialectical_framework-1.6.0 → dialectical_framework-1.6.2}/src/dialectical_framework/agents/analyst/system_prompts.py

@@ -77,6 +77,14 @@ When the user wants to explore interactions between perspectives:
    Only create separate if user deliberately wants a different scope.
 3. Confirm the exploration direction with the user before creating.
 
+**Grouping (which perspectives to combine):**
+- Prefer perspectives from different polarities (different T-A oppositions). Transformations
+  between different oppositions are genuine synthesis with opponents — the richest exploration.
+- Same-polarity grouping is still valid when it fits the intent or the user asks for it.
+  It produces "angle shifts" (reframing within one opposition) rather than cross-opposition
+  synthesis — note that tradeoff so the user knows what they'll get. Never refuse or override
+  an explicit same-polarity request.
+
 **Intent (internal quality gate — do not surface to user):**
 - Must be specific: what the user wants to understand or navigate.
 - Refine vague requests ("explore this") into purposeful intents internally.

{dialectical_framework-1.6.0 → dialectical_framework-1.6.2}/src/dialectical_framework/agents/execution_report.py

@@ -37,7 +37,9 @@ if TYPE_CHECKING:
     from dialectical_framework.events.graph_event_bus import GraphEventBus
     from dialectical_framework.graph.nodes.base_node import BaseNode
     from dialectical_framework.graph.relationship_manager import (
-        BoundRelationshipManager, RelationshipManager)
+        BoundRelationshipManager,
+        RelationshipManager,
+    )
     from dialectical_framework.utils.effect_logger import EffectLogger
 
 # Type alias for relationship type parameter
@@ -209,11 +211,13 @@ class ExecutionReport(BaseModel):
         if self._event_bus is None:
             return
         import asyncio
+
         try:
             loop = asyncio.get_running_loop()
         except RuntimeError:
             return
         from dialectical_framework.graph.scope_context import get_current_sid
+
         sid = get_current_sid()
         if sid:
             loop.create_task(self._event_bus.publish(sid, effect))
@@ -224,6 +228,7 @@ class ExecutionReport(BaseModel):
             return
         from dialectical_framework.agents.agent_context import get_current_agent
         from dialectical_framework.graph.scope_context import get_current_sid
+
         sid = get_current_sid()
         if not sid:
             return
@@ -239,6 +244,7 @@ class ExecutionReport(BaseModel):
             return
         from dialectical_framework.agents.agent_context import get_current_agent
         from dialectical_framework.graph.scope_context import get_current_sid
+
         sid = get_current_sid()
         if not sid:
             return
@@ -431,10 +437,16 @@ class ExecutionReport(BaseModel):
 
         merged_artifacts = {**self.artifacts, **other.artifacts}
 
-        return ExecutionReport(
+        merged = ExecutionReport(
             tool=self.tool,
             ok=self.ok and other.ok,
             summary=f"{self.summary}\n{other.summary}".strip(),
             effects=self.effects,
             artifacts=merged_artifacts,
         )
+        # Carry the sequence counter forward so subsequent _next_seq()/merge()
+        # calls continue the timeline. Without this the fresh report resets to
+        # 0, and chained merges (self._report = self._report.merge(...)) emit
+        # duplicate seq values.
+        merged._seq_counter = self._seq_counter
+        return merged