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

{dialectical_framework-1.5.5 → dialectical_framework-1.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dialectical-framework
-Version: 1.5.5
+Version: 1.6.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.5.5 → dialectical_framework-1.6.0}/pyproject.toml

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

@@ -132,103 +132,84 @@ 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 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.
+
+- `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
@@ -306,12 +287,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.5 → dialectical_framework-1.6.0}/src/dialectical_framework/agents/analyst/skills/expand_polarities.py

@@ -18,27 +18,36 @@ from pydantic import Field
 
 from dialectical_framework.agents.reasonable_concern import ReasonableConcern
 from dialectical_framework.enums.di import DI
-from dialectical_framework.concerns.aspect_generation import (AspectGeneration,
-                                                              AspectResult)
-from dialectical_framework.concerns.statement_deduplication import \
-    StatementDeduplication
+from dialectical_framework.concerns.aspect_generation import (
+    AspectGeneration,
+    AspectResult,
+)
+from dialectical_framework.concerns.statement_deduplication import (
+    StatementDeduplication,
+)
 from dialectical_framework.graph.nodes.polarity import Polarity
-from dialectical_framework.graph.nodes.perspective import (POSITION_A_MINUS,
-                                                           POSITION_A_PLUS,
-                                                           POSITION_T_MINUS,
-                                                           POSITION_T_PLUS,
-                                                           Perspective)
+from dialectical_framework.graph.nodes.perspective import (
+    POSITION_A_MINUS,
+    POSITION_A_PLUS,
+    POSITION_T_MINUS,
+    POSITION_T_PLUS,
+    Perspective,
+)
 from dialectical_framework.graph.relationships.polarity_relationship import (
-    AMinusRelationship, APlusRelationship, HasPolarityRelationship,
-    TMinusRelationship, TPlusRelationship)
-from dialectical_framework.graph.repositories.statement_repository import \
-    StatementRepository
-from dialectical_framework.graph.repositories.input_repository import \
-    InputRepository
-from dialectical_framework.graph.repositories.node_repository import \
-    NodeRepository
-from dialectical_framework.graph.repositories.perspective_repository import \
-    PerspectiveRepository
+    AMinusRelationship,
+    APlusRelationship,
+    HasPolarityRelationship,
+    TMinusRelationship,
+    TPlusRelationship,
+)
+from dialectical_framework.graph.repositories.statement_repository import (
+    StatementRepository,
+)
+from dialectical_framework.graph.repositories.input_repository import InputRepository
+from dialectical_framework.graph.repositories.node_repository import NodeRepository
+from dialectical_framework.graph.repositories.perspective_repository import (
+    PerspectiveRepository,
+)
 
 if TYPE_CHECKING:
     from dialectical_framework.protocols.input_resolver import InputResolver
@@ -51,20 +60,22 @@ class ExpandPolarity(ReasonableConcern[list[Perspective]]):
     Creates Perspectives from a Polarity by generating and connecting aspects
     (T+, T-, A+, A-).
 
-    Each call produces one NEW perspective (alternative tetrad) for the Polarity,
-    using `not_like_these` to ensure diversity from existing ones. Call multiple
-    times on the same Polarity to build a richer space of tetrads.
+    Each call produces `count` NEW perspectives (alternative tetrads) for the
+    Polarity, generated sequentially so each uses `not_like_these` (existing +
+    already-generated-this-call) to ensure diversity. Any pre-existing partial
+    Perspective counts toward `count`.
 
     Flow:
     1. Resolve Polarity by hash
     2. Look up existing Perspectives for this Polarity
-    3. If none exist, create a new Perspective
-    4. Complete all partial PPs by generating aspects
+    3. Create new partial Perspectives so `count` are generated this call
+    4. Complete all partial PPs sequentially by generating aspects
     5. Return list of completed Perspectives (existing + new)
     """
 
-    def __init__(self, polarity_hash: str) -> None:
+    def __init__(self, polarity_hash: str, count: int = 1) -> None:
         self.polarity_hash = polarity_hash
+        self.count = max(1, count)
 
     async def resolve(self) -> list[Perspective]:
         """
@@ -86,20 +97,17 @@ class ExpandPolarity(ReasonableConcern[list[Perspective]]):
         pp_repo = PerspectiveRepository()
         existing_pps = pp_repo.find_by_polarity(polarity)
 
-        if not existing_pps:
-            # No PP exists - create one referencing the Polarity
-            pp = self._create_perspective_for_polarity(polarity)
-            existing_pps = [pp]
-
         complete_pps = [pp for pp in existing_pps if pp.is_complete()]
         partial_pps = [pp for pp in existing_pps if not pp.is_complete()]
 
-        if not partial_pps:
-            # All existing perspectives are complete — create a new one
-            pp = self._create_perspective_for_polarity(polarity)
-            partial_pps = [pp]
+        # Complete any existing partials, then create additional new ones so that
+        # `count` fresh Perspectives are produced this call (a pre-existing partial
+        # counts as one of them).
+        additional_needed = self.count - len(partial_pps)
+        for _ in range(max(0, additional_needed)):
+            partial_pps.append(self._create_perspective_for_polarity(polarity))
 
-        # Complete all partial PPs
+        # Complete all partial PPs sequentially (each sees prior results)
         completed_pps: list[Perspective] = []
 
         for pp in partial_pps:
@@ -209,7 +217,12 @@ class ExpandPolarity(ReasonableConcern[list[Perspective]]):
 
     def _perspective_final_state(self, pp: Perspective) -> dict[str, str | None]:
         """Build a dict with the final post-dedup text at each position."""
-        positions = [POSITION_T_PLUS, POSITION_T_MINUS, POSITION_A_PLUS, POSITION_A_MINUS]
+        positions = [
+            POSITION_T_PLUS,
+            POSITION_T_MINUS,
+            POSITION_A_PLUS,
+            POSITION_A_MINUS,
+        ]
         state: dict[str, str | None] = {"hash": pp.short_hash}
         for pos in positions:
             manager = pp.get_relationship_manager_by_position(pos)
@@ -299,13 +312,22 @@ class ExpandPolarity(ReasonableConcern[list[Perspective]]):
 
 @llm.tool
 async def expand_polarities(
-    polarity_hashes: Annotated[list[str], Field(description="Hashes of Polarities to expand into full Perspectives")],
+    polarity_hashes: Annotated[
+        list[str],
+        Field(description="Hashes of Polarities to expand into full Perspectives"),
+    ],
+    count: Annotated[
+        int,
+        Field(
+            description="Number of new Perspectives to generate per Polarity (each is diverse from prior ones)"
+        ),
+    ] = 1,
 ) -> str:
-    """Build complete Perspectives from Polarities by generating evaluative aspects (T+, T-, A+, A-) for each. Each call generates one new Perspective per Polarity — call multiple times for alternative perspectives on the same Polarity (duplicates in a single call are ignored). The Polarities must already exist in the graph."""
+    """Build complete Perspectives from Polarities by generating evaluative aspects (T+, T-, A+, A-) for each. Generates `count` new Perspectives per Polarity sequentially — each sees prior tetrads to ensure diversity. The Polarities must already exist in the graph."""
     import asyncio
 
     async def _expand_one(h: str) -> str:
-        concern = ExpandPolarity(polarity_hash=h)
+        concern = ExpandPolarity(polarity_hash=h, count=count)
         await concern.resolve()
         return str(concern.report)
 

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

@@ -30,27 +30,35 @@ Choose your approach based on the user's input:
 - User provides substantial text describing a situation or dilemma
 - User says "analyze this" or provides content without specific direction
 - User wants comprehensive treatment end-to-end
+- Default for pasted substantial text unless the user signals they only want to store it for later
 
 **Use `find_polarities` / `expand_polarities` when:**
 - User is working step-by-step and asks for the next step
 - User refers to specific existing theses and wants tensions found
 - User explicitly asks to expand a polarity into perspectives
+- User asks to "find tetrads", "show aspects", "build T+/T-/A+/A-", or otherwise requests the four-aspect structure
+
+**Disambiguating "perspectives", "angles", "points of view":**
+These words map to DIFFERENT tools depending on what's in scope:
+- Polarity in view/referenced → `expand_polarities` (build the tetrad for that polarity)
+- Thesis in view/referenced → `find_polarities` (find opposing angles)
+- No specific node → check what exists: unexpanded polarities → `expand_polarities`; theses without polarities → `find_polarities`
 
 **Use `add_input` when:**
 - User provides multi-sentence source material (a paragraph, article, or detailed description) to capture before analysis
 - User shares a URL to process
 - User pastes a conversation fragment or external text block
+- Use only when the user wants to capture without analyzing yet ("save this", "for later", "just add this source"). If they want it understood now, use `analyze`.
 - NOT for single words, short phrases, or "add a statement X" — those go to `anchor_theses`
 
 ## How to Work
 
-Act on clear intent. Never ask "shall I analyze this?" — just do it.
+Act on clear intent for analysis actions (analyze, find/expand, anchor) — never ask "shall I analyze this?", just do it. Nexus creation is the one exception: confirm exploration direction first (see Exploration Setup).
 Always check resonance AFTER presenting results — but never before acting.
 
 - If the user describes a situation: call `analyze` or `introduce_polarity` depending on whether a clear tension is stated
 - If the user gives a single concept: call `anchor_theses` with that concept as a statement.
-- If the user disagrees with a generated aspect: offer `edit_perspective` with their correction, or `discard` if the whole perspective misses the mark.
-- If the user corrects or refines: use `edit_perspective` or `discard` immediately
+- If the user disagrees with or corrects a generated aspect: use `edit_perspective` with their correction, or `discard` if the whole perspective misses the mark.
 - If the user wants to explore interactions: see "Exploration Setup" section below
 - If the user asks "what do we have?": use `present_analysis`
 - If the user works step-by-step: follow their lead with granular tools
@@ -93,7 +101,7 @@ When the user wants to explore interactions between perspectives:
 - `surface_theses` — Extract theses from inputs (requires inputs in scope).
 - `find_polarities` — Find antitheses for existing theses.
 - `introduce_polarity` — Directly introduce a known T-A tension (both sides clear).
-- `expand_polarities` — Expand polarities into full Perspectives (T+/T-/A+/A-).
+- `expand_polarities` — Expand polarities into full Perspectives (T+/T-/A+/A-). Pass `count > 1` to generate several diverse tetrads per polarity in one call.
 - `place_statement` — Check if a statement exists in the graph already.
 
 **Steering:**

{dialectical_framework-1.5.5 → dialectical_framework-1.6.0}/src/dialectical_framework/agents/apps.py

@@ -220,8 +220,10 @@ anything — people need TRANSFORMATIONAL RECIPES: what to DO and what to
 REFLECT ON simultaneously for synthesis to actually emerge.
 
 A Nexus groups related positions for exploration. Within a Nexus, Wheels
-arrange positions into causal cycles — sequences where one position's
-exaggeration causally feeds into another's blindspot, forming a loop.
+arrange positions into causal cycles — a loop where each position's
+exaggeration feeds the next position's constructive strength (its
+overdevelopment becomes the opening the next one develops well), closing
+back on itself.
 
 Transformations sit on the edges of these cycles. Each transformation is
 bipolar (like a position): it has an action direction and a reflection
@@ -271,9 +273,12 @@ can have many oppositions → many polarities. Use: "this polarity",
 (T+/T-/A+/A-). The felt push-and-pull. Use: "this tension",
 "the push-and-pull between X and Y", "this conflict", "the structural tension".
 
-**T+ (constructive angle of the statement)** — depending on context:
-"the actual goal behind this", "the driving force", "what they're really after",
-"the strength of this position", "the intention", "what makes this valuable".
+**T+ (constructive angle of the statement)** — the position at its most
+constructive: developed well enough to deliver its value while still leaving room
+for what the opposition offers. That balance is exactly what separates it from T-
+(the same strength pushed too far). Depending on context: "the actual goal behind
+this", "the driving force", "what they're really after", "the strength of this
+position", "what makes this valuable without crowding out the other side".
 
 **T- (exaggerated angle of the statement)** — VISIBLE to the position-holder
 (not a blindspot). Depending on context: "the obvious risk", "what happens
@@ -341,8 +346,11 @@ both sides contribute", "constructive co-existence", "where 1+1 > 2".
 
 ## Viewport Scope
 
-Messages may include context about what the user is currently viewing. This tells you their active focus. Respect it:
+Messages may begin with `[User is currently viewing: ...]`. This tells you their active focus — use it to resolve ambiguous requests:
 
+- When the user asks for an action without specifying a target (e.g., "find tetrads", "expand", "show aspects", "find perspectives"), apply it to the node in their current view.
+- If a polarity is in view and the user asks for tetrads/aspects/perspectives/angles, expand that polarity into its full structure.
+- If a thesis is in view and the user asks for perspectives/angles/oppositions, find opposing viewpoints for that thesis.
 - Only operate on the node(s) in the user's viewport unless they explicitly reference something else or ask to switch.
 - Never silently pivot to other nodes outside the viewport. If you think working on a different node would help, ask first.
 
@@ -475,10 +483,12 @@ You respect them by not wasting their time with soft landings.
 """
 
 ADVANCED_APP = DEFAULT_APP + """
-## Advanced Interaction (overrides Presentation Defaults above)
+## Advanced Interaction (overrides Contextual Vocabulary and Presentation Defaults above)
 
 The user understands the dialectical framework, graph model, and generative
-rules. Adjust interaction accordingly:
+rules. The "Do NOT use a fixed translation table" guidance above is written for
+non-expert users and does not apply here — use precise framework vocabulary
+directly. Adjust interaction accordingly:
 
 - Always use framework vocabulary: Thesis, Antithesis, T+, T-, A+, A-,
   Polarity, Perspective, Wheel, Cycle, Transformation, Nexus, Transition.
@@ -487,5 +497,5 @@ rules. Adjust interaction accordingly:
 - Present tetrads structurally with all six positions and scores.
 - Show transformation positions explicitly: Ac, Ac+, Ac-, Re, Re+, Re-.
 - Show control statements, modality alignment, diagonal contradictions.
-- Suggest next steps but don't auto-execute — the user drives.
+- Suggest exploration-phase next steps (nexus, wheels) rather than auto-executing — the user drives structural expansion. Analysis tools (expand, find) still follow "act on clear intent."
 """

{dialectical_framework-1.5.5 → dialectical_framework-1.6.0}/src/dialectical_framework/agents/explorer/skills/explore_transformations.py

@@ -706,7 +706,7 @@ class ExploreTransformations(ReasonableConcern[ExploreTransformationsResult]):
 
         Args:
             headline: Short headline (~7 words) - stored on Transition.instruction
-            statement: Fuller statement (1-15 words) - stored on Transition.summary
+            statement: Fuller statement (longer than headline) - stored on Transition.summary
             source: The source component (e.g., T-)
             target: The target component (e.g., A+)
             explanation: Full reasoning - stored on Rationale.text (evidence/justification)

{dialectical_framework-1.5.5 → dialectical_framework-1.6.0}/src/dialectical_framework/agents/explorer/system_prompts.py

@@ -22,7 +22,8 @@ for structural combination. Your job is to guide the user through three phases:
 On first message (or when resuming):
 - Call `present_exploration` to see what's been built in this Nexus.
 - If wheels don't exist yet, call `build_wheels` to create them.
-- If build_wheels yields no wheels (e.g., only one position), explain that exploration needs at least two positions interacting — suggest the user adds more via the analysis thread.
+- If `build_wheels` yields no wheels, this Nexus has no perspectives attached yet — suggest the user adds some via the analysis thread.
+- A single perspective builds one self-referential wheel — usable, but limited to one opposition. Genuine synthesis emerges when two or more perspectives interact, so encourage adding more for richer exploration.
 
 After wheels exist — present the causality landscape:
 - Show which wheels exist and their causality scores (higher = more plausible).
@@ -76,6 +77,5 @@ Adapt depth and presentation to the persona defined in the app preamble.
 - Never rephrase Statement text. Use exact text (or display_text) from the graph — paraphrasing makes it ambiguous which node you're referring to.
 - When referencing structural nodes (Polarity, Perspective, Nexus, Cycle, Wheel, Transformation, Transition, Synthesis), always include the short hash for disambiguation.
 - If the user wants to analyze new material, suggest they return to the analysis thread.
-- Skill reports may contain truncated text previews. When you need to present exact node text to the user, use `inspect_node` or `present_analysis` by hash — never reconstruct or guess full text from truncated previews.
-- Do NOT eagerly explore all wheels or generate all syntheses. Let the user navigate and choose.
+- Skill reports may contain truncated text previews. When you need to present exact node text to the user, use `inspect_node` or `present_exploration` by hash — never reconstruct or guess full text from truncated previews.
 """

{dialectical_framework-1.5.5 → dialectical_framework-1.6.0}/src/dialectical_framework/concerns/action_extraction.py

@@ -63,8 +63,8 @@ Your task is to generate Ac+ candidates that represent T- → A+ transition path
 ## What is Ac+?
 
 The +/- notation is STRUCTURAL (like electrical charges), not a value judgment:
-- "+" aspects target beneficial states (T+ or A+)
-- "-" aspects target problematic states (T- or A-)
+- "+" transitions target beneficial states (T+ or A+)
+- "-" transitions target problematic states (T- or A-)
 
 Ac+ is an "action targeting A+" - a way of acting/behaving that helps someone escape the problematic aspects of the thesis (T-) and move toward the healthy aspects of the antithesis (A+).
 
@@ -111,7 +111,7 @@ APEX
 2. Must help transition FROM T- (problem) TOWARD A+ (benefit)
 3. Must NOT simply restate A+ - it's the PATH, not the destination
 4. Should be generative: enable discovery rather than prescribe specific outcomes
-5. Length: 1-15 words, actionable and memorable
+5. Length: a fuller actionable form, longer than the headline
 6. Choose the insight level that best matches the nature of the action
 """
 
@@ -120,7 +120,7 @@ class ActionCandidateDto(BaseModel):
     """A candidate Ac+ statement with coordinates."""
 
     headline: str = Field(description="Short headline (component length)")
-    statement: str = Field(description="The Ac+ statement (1-15 words)")
+    statement: str = Field(description="The Ac+ statement (fuller than the headline)")
     insight_label: str = Field(
         description="Insight level: leverage/anticipation/composition/etc"
     )
@@ -270,7 +270,7 @@ The Ac+ must:
 2. Pick the specific insight label from [{levels_str}] that best fits your action
 3. Choose the appropriate action category (Coordination/Intervention/Implementation/Configuration/Governance/Stewardship)
 4. Provide a short headline (~{self.settings.component_length} words) - the essence of the action
-5. Provide a fuller statement/summary (1-15 words) - actionable and memorable
+5. Provide a fuller statement/summary (up to {self.settings.transition_length} words) - actionable and memorable
 6. Provide a haiku (3 lines, 5-7-5 syllables) capturing the action's essence — easy to memorize
 
 Focus on the T- → A+ transition path, not the destination."""