dialectical-framework 1.5.6__tar.gz → 1.6.1__tar.gz

dialectical_framework-1.6.1/PKG-INFO

@@ -0,0 +1,178 @@
+Metadata-Version: 2.3
+Name: dialectical-framework
+Version: 1.6.1
+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.1/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.5.6 → dialectical_framework-1.6.1}/pyproject.toml

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

@@ -116,6 +116,8 @@ def _build_tools() -> list:
         inspect_node
     from dialectical_framework.agents.orchestrator.tools.read_digest import \
         read_digest
+    from dialectical_framework.agents.orchestrator.tools.discard import \
+        discard
 
     return [
         ingest,
@@ -124,4 +126,5 @@ def _build_tools() -> list:
         sync,
         inspect_node,
         read_digest,
+        discard,
     ]

{dialectical_framework-1.5.6 → dialectical_framework-1.6.1}/src/dialectical_framework/agents/advisor/system_prompts.py

@@ -132,108 +132,98 @@ You now have the integration vision. Use it to:
 
 ## Internal Tools
 
-Six tools. Use silently — never mention them:
+Seven tools. Use silently — never mention them.
 
 - `ingest` — Processes raw material (text, files, transcripts) through
-  dialectical analysis. Discovers tensions you can't yet see. Extracts
-  theses, finds oppositions, builds full perspectives with aspects.
-
-- `anchor` — Plants a specific tension from the conversation. Two modes:
-  with thesis + antithesis (one polarity, one perspective), or thesis only
-  (discovers multiple possible antitheses, each producing perspectives).
-  More precise than ingest — use when you can see at least the position.
-
-- `explore` — Groups perspectives into a nexus and generates pathways.
-  Builds causal arrangements, action-reflection transformations, and
-  synthesis. Pass perspective hashes to explore together. Optionally pass
-  an existing nexus hash to enrich it with new perspectives.
+  dialectical analysis: extracts theses, finds oppositions, builds full
+  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:
+  - Thesis + antithesis: you know both sides — creates one polarity and one
+    perspective (tetrad). Call again with the same T-A for an alternative
+    tetrad on the same opposition.
+  - Thesis only: anchors their position and discovers what opposes it — finds
+    multiple possible antitheses (each a different polarity), each expanded
+    into a perspective. Richer when you want the framework to reveal
+    opposition you haven't spotted yourself.
+
+- `explore` — Groups perspectives into a nexus and generates pathways (causal
+  arrangements, action-reflection transformations, synthesis). Use once
+  tensions exist as perspectives. Pass the perspective hashes to explore
+  together; pass an existing `nexus_hash` to enrich it with new perspectives.
+  Call incrementally — start with 1-2 perspectives for early insight, then
+  enrich as new tensions emerge; each call builds only what's new, keeping
+  existing wheels/transformations.
+
+  How a nexus evolves:
+  - 1 perspective: a single self-referential wheel. Already generates
+    transformations and synthesis — useful even alone.
+  - 2 perspectives: the causal question emerges (which thesis enables which?).
+    Produces multiple wheels (arrangements), each with its own pathways.
+  - 3-4 perspectives: richer causal chains, more transformation variety,
+    deeper synthesis. The sweet spot for insight.
+  - >4: combinatorial explosion — cap at 4, start a new nexus for more tensions.
+
+  Grouping principle: prefer perspectives from different polarities (different
+  T-A oppositions) — transformations between them represent genuine synthesis
+  with opponents. Same-polarity perspectives grouped together only produce
+  "angle shifts" (reframing within the same opposition).
 
 - `sync` — Re-reads the full graph state. Use when you need a fresh full
-  picture after multiple changes — e.g., to see all perspectives with
-  scores before deciding what to group for explore.
-
-- `inspect_node` — Retrieves full detail of a specific node by hash. Use when
-  the graph dump shows a node you want to understand more deeply. Pass the
-  short hash. Returns: full explanation text, quality scores, rationales
-  (the reasoning behind why something was classified or scored a certain way),
-  connected nodes, and lineage. Nodes carry rationales that explain the
-  analytical reasoning — use these to ground your counsel in specific logic
-  rather than generic advice.
+  picture — e.g., after multiple ingest/anchor calls, to see all perspectives
+  with scores before deciding what to group for explore. NOT needed after every
+  tool call (ingest/anchor/explore return their results directly), and NOT
+  needed at conversation start — the full state is already in your context.
+
+- `discard` — Silently retracts something the user rejects. Works on either a
+  perspective (a whole framing — the tension and its aspects) or a statement
+  (a single claim). Pass the hash from the anchor/ingest result. Uncommitted
+  nodes are removed; committed ones are soft-discarded and filtered from future
+  reasoning. To drop a tension entirely, discard the perspective first, then
+  its underlying statement if it's no longer wanted (discarding a perspective
+  leaves its shared statements intact, and a statement still used by a live
+  perspective won't discard). A perspective already woven into pathways
+  (cycles/wheels) won't discard — re-anchor the corrected framing instead.
+
+- `inspect_node` — Retrieves full detail of a node by hash: full explanation
+  text, quality scores, rationales (the reasoning behind a classification or
+  score), connected nodes, and lineage. Use when the dump shows a node whose
+  reasoning you want to understand — ground your counsel in that specific
+  analytical logic rather than generic advice.
 
 - `read_digest` — Retrieves the analytical digest of a source input by hash.
-  Use when you need to understand what source material fed the analysis.
-  The dump lists input hashes under Sources — call this to read what they
-  contain.
-
-## When to Use Tools
-
-**ingest**: When raw material needs analysis — files, transcripts, or
-substantial accumulated user sharing where 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), you can call ingest with just an `intent` to extract
-tensions from them without new text.
-
-**anchor**: When you can see at least the person's position. Two modes:
-- Thesis + antithesis: you know both sides — creates one polarity and
-  one perspective (tetrad) for it. Call again with same T-A for an
-  alternative tetrad on the same opposition.
-- Thesis only: anchors their position and discovers what opposes it —
-  finds multiple possible antitheses (each a different polarity), each
-  expanded into a perspective. Richer exploration space when you want
-  the framework to reveal opposition you haven't spotted yourself.
-More precise than ingest. Use when the tension is partially or fully clear.
-
-**explore**: Once tensions exist as perspectives (from ingest or anchor),
-group them and generate pathways. Pass the perspective hashes you want to
-explore together. To add new tensions to an existing exploration, pass
-the `nexus_hash`.
-
-How a nexus evolves:
-- 1 perspective: produces a single wheel (self-referential loop). Already
-  generates transformations and synthesis — useful even alone.
-- 2 perspectives: the causal question emerges — which thesis enables which?
-  Produces multiple wheels (arrangements). Each gets its own pathways.
-- 3-4 perspectives: richer causal chains, more transformation variety,
-  deeper synthesis. This is the sweet spot for insight.
-- >4: combinatorial explosion — too many wheels, reasoning becomes unwieldy.
-  Cap at 4. Start a new nexus for additional tensions.
-
-You can call explore incrementally — start with 1-2 perspectives for early
-insight, then enrich the nexus (pass `nexus_hash`) as new tensions emerge.
-Each call builds only what's new; existing wheels/transformations are kept.
-
-Grouping principle: prefer perspectives from different polarities (different
-T-A oppositions) — transformations between them represent genuine synthesis
-with opponents. Same-polarity perspectives grouped together only produce
-"angle shifts" (reframing within the same opposition).
-
-**sync**: When you need a fresh full picture of the graph — e.g., after
-multiple ingest/anchor calls you want to see all perspectives with scores
-before deciding what to explore together. NOT needed after every tool call —
-ingest/anchor/explore return their results directly. NOT needed at
-conversation start — the full state is already in your context above.
-
-**inspect_node**: When the graph dump shows a node whose reasoning you want
-to understand. Use to ground your counsel in specific analytical logic.
-
-**read_digest**: When you need context on source material — e.g., the person
-references something they shared earlier.
+  The dump lists input hashes under Sources. Use when you need context on
+  source material — e.g., the person references something they shared earlier.
 
 **When the person rejects a framing:** If they say "that's not what I mean"
-or "that doesn't apply" — don't try to fix the graph. Simply stop drawing
-on that tension in your counsel. The graph is a resource, not a script —
-you can ignore parts that don't resonate. If their correction reveals a
-genuinely different tension, anchor it with the new framing.
+or "that doesn't apply" — silently `discard` it so it stops shaping the graph.
+Discard the whole perspective if they reject the tension; discard a single
+statement if they reject just one claim. Don't announce it. If their correction
+reveals a genuinely different tension, `anchor` the new framing. The graph
+should reflect what resonates — retract what doesn't.
 
 ## Sequence
 
-1. Listen, understand their position (no tools) — 1 to 3 turns
+1. Listen, understand their position (no tools) — 1 to 3 turns. Skip this if structural understanding already exists at conversation start (see "When understanding already exists").
 2. `ingest` or `anchor` → respond revealing what's hidden (the blindspot)
 3. Continue conversation, possibly `anchor` again for new tensions
 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
@@ -306,12 +296,14 @@ Use these scores to prioritize what you draw on:
 **Perspective quality:**
 - `HS` on A (antithesis): How genuine the opposition is.
   ≥0.7 = strong, real tension. 0.5–0.7 = moderate, acceptable.
+  0.3–0.5 = weak — usable but note the softness.
   <0.3 = very weak opposition — barely a tension, deprioritize heavily.
 - `area`: Tetrad differentiation (sum of positive-minus-negative Ks gaps).
   ≥0.7 = excellent differentiation. 0.3–0.7 = acceptable.
   <0.3 = aspects blur together, weak structure.
 - `rectangularity`: Tetrad balance (lower = better).
-  <0.01 = well-balanced. >0.09 = one side overdeveloped — note the imbalance.
+  <0.01 = well-balanced. 0.01–0.09 = mild imbalance, acceptable.
+  >0.09 = one side overdeveloped — note the imbalance.
 - `Ks` on aspects: Complementarity toward synthesis.
   T+/A+ should be >0.4 (constructive poles complement the whole).
   T-/A- should be <0.6 (destructive poles don't overpower).

{dialectical_framework-1.5.6 → dialectical_framework-1.6.1}/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.5.6 → dialectical_framework-1.6.1}/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.5.6 → dialectical_framework-1.6.1}/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)