dialectical-framework 1.7.0__tar.gz → 1.7.1__tar.gz

{dialectical_framework-1.7.0 → dialectical_framework-1.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dialectical-framework
-Version: 1.7.0
+Version: 1.7.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

{dialectical_framework-1.7.0 → dialectical_framework-1.7.1}/pyproject.toml

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

@@ -20,6 +20,7 @@ from pydantic import BaseModel, Field
 from dialectical_framework.agents.advisor.system_prompts import \
     system_prompt
 from dialectical_framework.agents.agent_context import agent_scope
+from dialectical_framework.graph.scope_context import require_current_sid
 from dialectical_framework.agents.conversation_facilitator import \
     ConversationFacilitator
 from dialectical_framework.agents.app_spec import AppSpec, resolve_app_layer
@@ -120,7 +121,15 @@ class Advisor:
         nexus_hash: Optional[str] = None,
         app_tools: Optional[list] = None,
         app: Optional[AppSpec] = None,
+        principal: str = "human",
     ) -> None:
+        # principal: WHO confirms decisions in this conversation — a host
+        # attestation, fixed for the session (the counterpart doesn't change
+        # mid-conversation). "human" = an actual person; a delegated driver
+        # (agent-to-agent runs) must pass its own identity ("agent:<name>"
+        # or <provider>/<model>) so recorded decisions never claim human
+        # confirmation they didn't get. Closed over by record_decision —
+        # never an LLM-visible parameter.
         self._nexus_hash = nexus_hash
         # app: declarative app definition — composition depends on the mode:
         # counsel toggle (nexus_hash set) keeps the Navigator contract
@@ -134,9 +143,9 @@ class Advisor:
         )
         if nexus_hash:
             self._validate_nexus(nexus_hash)
-            self._tools = _build_scoped_tools(nexus_hash)
+            self._tools = _build_scoped_tools(nexus_hash, principal)
         else:
-            self._tools = _build_tools()
+            self._tools = _build_tools(principal)
         # App-provided @llm.tool functions (domain resources: chart lookups,
         # methodology references, ...) — see toolsets.merge_app_tools.
         self._tools = merge_app_tools(self._tools, app_tools)
@@ -185,12 +194,14 @@ class Advisor:
         return "\n\n".join(parts)
 
     async def chat(self, user_message: str) -> str:
+        require_current_sid()  # unscoped turns silently drop all work
         with agent_scope(self.AGENT_NAME):
             await self._render_pending_context()
             result = await self._conversation.submit(ChatResponse, user_message)
             return result.message
 
     async def chat_stream(self, user_message: str) -> AsyncGenerator[StreamEvent, None]:
+        require_current_sid()  # unscoped turns silently drop all work
         with agent_scope(self.AGENT_NAME):
             await self._render_pending_context()
             async for event in self._conversation.submit_stream(
@@ -233,13 +244,13 @@ class Advisor:
         return self._conversation._messages
 
 
-def _build_tools() -> list:
+def _build_tools(principal: str = "human") -> list:
     from dialectical_framework.agents.advisor.tools.anchor import anchor
     from dialectical_framework.agents.advisor.tools.deepen import deepen
     from dialectical_framework.agents.advisor.tools.explore import explore
     from dialectical_framework.agents.advisor.tools.ingest import ingest
     from dialectical_framework.agents.advisor.tools.record_decision import \
-        record_decision
+        build_record_decision
     from dialectical_framework.agents.advisor.tools.sync import sync
     from dialectical_framework.agents.orchestrator.tools.inspect_node import \
         inspect_node
@@ -253,7 +264,7 @@ def _build_tools() -> list:
         anchor,
         explore,
         deepen,
-        record_decision,
+        build_record_decision(principal),
         sync,
         inspect_node,
         read_digest,
@@ -261,8 +272,8 @@ def _build_tools() -> list:
     ]
 
 
-def _build_scoped_tools(nexus_hash: str) -> list:
+def _build_scoped_tools(nexus_hash: str, principal: str = "human") -> list:
     from dialectical_framework.agents.advisor.tools.scoped import \
         build_scoped_tools
 
-    return build_scoped_tools(nexus_hash)
+    return build_scoped_tools(nexus_hash, principal)

dialectical_framework-1.7.1/src/dialectical_framework/agents/advisor/tools/record_decision.py

@@ -0,0 +1,85 @@
+"""
+record_decision tool: persist a decision the person explicitly confirmed.
+
+The ceremony lives in conversation (propose → read back → confirm) — this
+tool is called only AFTER the person's explicit yes, with the confirmed
+wording passed literally. Retracting or replacing a recorded decision goes
+through the standard `discard` tool (reason referencing the new decision).
+
+Provenance: WHO confirmed is a host-attested fact, closed over at tool
+construction (Advisor(principal=...)) — never an LLM-supplied parameter.
+"human" (the default) means an actual person confirmed the wording; a
+delegated driver (agent-to-agent runs) must be constructed with its own
+identity, else the ledger and inspect_node would present machine-authored
+rationales as the person's own confirmed "why".
+"""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+from mirascope import llm
+from pydantic import Field
+
+from dialectical_framework.concerns.record_decision import GroundLink
+
+
+def build_record_decision(principal: str = "human"):
+    """Build the record_decision tool with the confirming principal
+    closed over (same code-not-prompt enforcement as the nexus pin in
+    scoped.py)."""
+
+    attested_principal = principal
+
+    @llm.tool
+    async def record_decision(
+        question: Annotated[
+            str,
+            Field(description="The question that was being decided, in the person's confirmed words"),
+        ],
+        stance: Annotated[
+            str,
+            Field(description="The stance the person committed to, in their confirmed words"),
+        ],
+        rationale: Annotated[
+            str,
+            Field(
+                description="The distilled why behind the decision as the person confirmed it, "
+                "including reasons that live outside the mapped structure (deadlines, "
+                "people, external facts)"
+            ),
+        ],
+        grounds: Annotated[
+            list[GroundLink] | None,
+            Field(
+                description="Nodes this decision rests on: {hash, role?} each. "
+                "role='accepted_cost' for the unchosen side's contribution the person "
+                "confronted and accepted; role='adopted_pathway' for the pathway adopted "
+                "as the ongoing recipe; omit role for a plain ground (tensions weighed, "
+                "arrangements counseled from)."
+            ),
+        ] = None,
+    ) -> str:
+        """Record a decision the person has EXPLICITLY confirmed in conversation. Never call this silently or speculatively — propose the distilled record first, read it back, and record only on their clear yes. Links the decision to the graph nodes that grounded it and attaches the confirmed rationale. To replace or retract a recorded decision, use `discard` on it (with a reason naming the newer decision if one replaces it)."""
+        from dialectical_framework.concerns.record_decision import RecordDecision
+
+        # Mirascope passes json.loads'd kwargs without coercing nested models, so
+        # `grounds` arrives as raw dicts — RecordDecision.resolve normalizes them
+        # (single owner of that normalization) and refuses in-band on bad input.
+        concern = RecordDecision()
+        await concern.resolve(
+            question=question,
+            stance=stance,
+            rationale=rationale,
+            grounds=grounds,
+            principal=attested_principal,
+        )
+        return str(concern.report)
+
+    return record_decision
+
+
+# Default build: a human principal. Kept module-level so existing imports
+# (toolset builders, tests) stay valid; hosts with a non-human driver pass
+# principal= at Advisor construction instead of importing this.
+record_decision = build_record_decision()

{dialectical_framework-1.7.0 → dialectical_framework-1.7.1}/src/dialectical_framework/agents/advisor/tools/scoped.py

@@ -32,23 +32,26 @@ from mirascope import llm
 from pydantic import Field
 
 
-def build_scoped_tools(nexus_hash: str) -> list:
+def build_scoped_tools(nexus_hash: str, principal: str = "human") -> list:
     """
     Build the tool set for an exploration-pinned Advisor (counsel mode).
 
     The nexus_hash is captured by closure — the LLM cannot redirect any of
     these tools to another nexus or create a new one. Validation that the
     nexus exists happens in Advisor.__init__, not here (keeps the factory
-    DB-free for signature tests).
+    DB-free for signature tests). `principal` (host-attested confirmer
+    identity, closed over the same way) reaches record_decision — see
+    tools/record_decision.py.
     """
     from dialectical_framework.agents.advisor.tools.anchor import anchor
     from dialectical_framework.agents.advisor.tools.record_decision import \
-        record_decision
+        build_record_decision
     from dialectical_framework.agents.orchestrator.tools.inspect_node import \
         inspect_node
     from dialectical_framework.agents.orchestrator.tools.read_digest import \
         read_digest
 
+    record_decision = build_record_decision(principal)
     pinned_hash = nexus_hash
 
     @llm.tool

{dialectical_framework-1.7.0 → dialectical_framework-1.7.1}/src/dialectical_framework/agents/analyst/analyst.py

@@ -16,6 +16,7 @@ from mirascope import llm
 from pydantic import BaseModel, Field
 
 from dialectical_framework.agents.agent_context import agent_scope
+from dialectical_framework.graph.scope_context import require_current_sid
 from dialectical_framework.agents.analyst.system_prompts import SYSTEM_PROMPT
 from dialectical_framework.agents.conversation_facilitator import \
     ConversationFacilitator
@@ -93,11 +94,13 @@ class Analyst:
         return "\n\n".join(parts)
 
     async def chat(self, user_message: str) -> str:
+        require_current_sid()  # unscoped turns silently drop all work
         with agent_scope(self.AGENT_NAME):
             result = await self._conversation.submit(ChatResponse, user_message)
             return result.message
 
     async def chat_stream(self, user_message: str) -> AsyncGenerator[StreamEvent, None]:
+        require_current_sid()  # unscoped turns silently drop all work
         with agent_scope(self.AGENT_NAME):
             async for event in self._conversation.submit_stream(
                 ChatResponse, user_message

{dialectical_framework-1.7.0 → dialectical_framework-1.7.1}/src/dialectical_framework/agents/analyst/system_prompts.py

@@ -67,6 +67,17 @@ Always check resonance AFTER presenting results — but never before acting.
 When new tensions emerge from conversation:
 - Call `analyze` with `thesis_hashes` to develop them without re-processing everything.
 
+**When the user declares a decision** ("that settles it, I'm going with X")
+or asks to have a decision noted or recorded: you cannot record decisions —
+that happens in the advisory conversation, not here. NEVER claim to have
+noted a decision yourself, and NEVER anchor the declared choice as a thesis —
+a decision is a stance the user takes, not a tension to analyze; persisting
+it as a statement would misfile it in the analytical structure. Acknowledge
+their choice plainly and continue the structural work; if the application
+offers an advisory conversation, point them there for recording. Decisions
+already recorded are readable: they appear via `query_graph` (Decision
+nodes) and `inspect_node` by hash.
+
 **Inputs from exploration (`dx://` URIs) — the round-trip.** An input whose
 content starts with `dx://` is an exploration insight fed back for analysis:
 it references a Transition (an action/reflection pathway) whose wisdom

{dialectical_framework-1.7.0 → dialectical_framework-1.7.1}/src/dialectical_framework/agents/explorer/explorer.py

@@ -16,6 +16,7 @@ from mirascope import llm
 from pydantic import BaseModel, Field
 
 from dialectical_framework.agents.agent_context import agent_scope
+from dialectical_framework.graph.scope_context import require_current_sid
 from dialectical_framework.agents.conversation_facilitator import \
     ConversationFacilitator
 from dialectical_framework.agents.explorer.system_prompts import system_prompt
@@ -109,11 +110,13 @@ class Explorer:
         return "\n\n".join(parts)
 
     async def chat(self, user_message: str) -> str:
+        require_current_sid()  # unscoped turns silently drop all work
         with agent_scope(self.AGENT_NAME):
             result = await self._conversation.submit(ChatResponse, user_message)
             return result.message
 
     async def chat_stream(self, user_message: str) -> AsyncGenerator[StreamEvent, None]:
+        require_current_sid()  # unscoped turns silently drop all work
         with agent_scope(self.AGENT_NAME):
             async for event in self._conversation.submit_stream(
                 ChatResponse, user_message

{dialectical_framework-1.7.0 → dialectical_framework-1.7.1}/src/dialectical_framework/agents/orchestrator/tools/get_schema.py

@@ -31,7 +31,7 @@ GRAPH_SCHEMA = """## Graph Schema
 | Transformation | Action-reflection structure (Ac, Re, Ac+, Ac-, Re+, Re-) on a Wheel edge | `intent` |
 | Transition | Movement between two Statements (source → target) | `statement`, `headline`, `haiku` |
 | Synthesis | Emergent S+/S- pair from a Wheel's circular causality | |
-| Decision | User-confirmed decision: question + stance (Case-level, immutable; timestamp = `committed_at`; the why = attached Rationale with `agent`="human") | `intent` (the question), `stance`, `discarded`, `validation` ("passed" / "failed: ..." / null=unchecked) |
+| Decision | Confirmed decision: question + stance (Case-level, immutable; timestamp = `committed_at`; the why = attached Rationale whose `agent` names the confirming principal — "human" for a person, "agent:<name>" for a delegated driver) | `intent` (the question), `stance`, `discarded`, `validation` ("passed" / "failed: ..." / null=unchecked) |
 | Rationale | Explanation attached to any node | `text` |
 | Estimation | Numeric assessment (probability, relevance, feasibility) | `value` |
 

{dialectical_framework-1.7.0 → dialectical_framework-1.7.1}/src/dialectical_framework/agents/orchestrator/tools/inspect_node.py

@@ -288,7 +288,15 @@ def _inspect_decision(decision: Decision) -> str:
     lines.append(f"Stance: {decision.stance}")
 
     for rationale, _ in decision.rationales.all():
-        prefix = "Why (human)" if rationale.agent == "human" else f"Rationale ({rationale.agent})"
+        # "human" = a person confirmed the ceremony; "agent:<name>" = a
+        # delegated driver confirmed (still the ceremony why, attributed);
+        # anything else = machine-generated analysis (critique etc.).
+        if rationale.agent == "human":
+            prefix = "Why (human)"
+        elif rationale.agent and rationale.agent.startswith("agent:"):
+            prefix = f"Why (confirmed by {rationale.agent})"
+        else:
+            prefix = f"Rationale ({rationale.agent})"
         lines.append(f"{prefix}: {rationale.text}")
 
     grounds = decision.grounds.all()

{dialectical_framework-1.7.0 → dialectical_framework-1.7.1}/src/dialectical_framework/concerns/dialectical_context.py

@@ -252,12 +252,20 @@ class DialecticalContext(ReasonableConcern[str], SettingsAware):
             # raw they could fabricate sibling ledger lines (injection).
             lines.append(f"Question: {one_line(d.intent)}")
             lines.append(f"Stance: {one_line(d.stance)}")
-            # Ledger shows only the human-confirmed why; machine rationales
+            # Ledger shows only the ceremony-confirmed why; machine rationales
             # (critiques etc.) stay one inspect_node away — deliberate
-            # divergence from _inspect_decision, which shows all.
+            # divergence from _inspect_decision, which shows all. "human" =
+            # a person confirmed; "agent:<name>" = a delegated driver
+            # confirmed (rendered with attribution so a human reading the
+            # ledger never mistakes it for their own confirmation).
             for rationale, _ in d.rationales.all():
                 if rationale.agent == "human":
                     lines.append(f"Why: {one_line(rationale.text)}")
+                elif rationale.agent and rationale.agent.startswith("agent:"):
+                    lines.append(
+                        f"Why (confirmed by {rationale.agent}): "
+                        f"{one_line(rationale.text)}"
+                    )
             if d.validation:
                 lines.append(f"Validation: {one_line(d.validation)}")
             grounds = d.grounds.all()
@@ -514,10 +522,13 @@ class DialecticalContext(ReasonableConcern[str], SettingsAware):
             total_wheel_prob = sum(p for p in wheel_probs.values() if p is not None)
 
             max_wheels = 0 if self._nexus_hash else self.settings.advisor_wheel_quality_top_plausible
+            # Hash tiebreaker: with probability-only keys, tied (or unscored)
+            # wheels resolve by arrival order — unspecified in Cypher — so
+            # which wheel makes the rendered top-N could differ between two
+            # renders of the SAME graph. The hash pins it.
             rendered = sorted(
                 wheels,
-                key=lambda w: wheel_probs.get(w._id) or -1.0,
-                reverse=True,
+                key=lambda w: (-(wheel_probs.get(w._id) or -1.0), w.hash or ""),
             )
             hidden = 0
             if max_wheels > 0 and len(rendered) > max_wheels:

{dialectical_framework-1.7.0 → dialectical_framework-1.7.1}/src/dialectical_framework/concerns/record_decision.py

@@ -9,7 +9,9 @@ confirmed wording, never as instructions to interpret. The concern:
    fail-closed for grounds, since a dangling or reader-invisible ground
    would break the record's value)
 2. Commits the Decision (question rides intent, stance frozen in hash)
-3. Attaches the distilled why as a Rationale with agent="human"
+3. Attaches the distilled why as a Rationale carrying the confirming
+   principal's provenance (agent="human" only when a person confirmed;
+   delegated drivers pass their own identity — see resolve())
 4. Connects GROUNDED_IN edges with their roles
 5. Runs DecisionCoherenceCheck and flags the verdict (fail-soft: a failed
    or errored check NEVER blocks the record — soft gate)
@@ -62,7 +64,19 @@ class RecordDecision(ReasonableConcern[str | None]):
         stance: str,
         rationale: str,
         grounds: list[GroundLink] | None = None,
+        principal: str = "human",
     ) -> str | None:
+        """
+        `principal` is the provenance stamped on the decision's Rationale —
+        WHO confirmed the recording ceremony. "human" (default) is the
+        sentinel meaning an actual person confirmed the wording; a delegated
+        driver (agent-to-agent runs) must pass its own identity (e.g.
+        "agent:<name>" or a <provider>/<model> string) — the ledger and
+        inspect_node render only human-confirmed rationales as the person's
+        own "why", so a false "human" here corrupts the record's authority
+        semantics unfixably. Attested by the HOST at agent construction
+        (Advisor(principal=...)), never by the LLM.
+        """
         from dialectical_framework.concerns.decision_coherence_check import \
             DecisionCoherenceCheck
         from dialectical_framework.graph.nodes.assessable_entity import \
@@ -170,12 +184,13 @@ class RecordDecision(ReasonableConcern[str | None]):
         # a raw exception hiding that a Decision now exists.
         attach_failures: list[str] = []
         try:
-            # The distilled why: a human-provenance Rationale.
+            # The distilled why: a Rationale carrying the confirming
+            # principal's provenance (see resolve() docstring).
             why = Rationale(text=rationale)
-            why.agent = "human"  # overwrite the auto-filled model identifier
+            why.agent = principal  # overwrite the auto-filled model identifier
             why.set_explanation_target(decision)
             why.commit()  # auto-connects EXPLAINS
-            self._report.node_created(why, patch={"agent": "human"})
+            self._report.node_created(why, patch={"agent": principal})
             self._report.relationship_created(why.explains, why, decision)
         except Exception as e:
             attach_failures.append(f"rationale not attached ({e})")

{dialectical_framework-1.7.0 → dialectical_framework-1.7.1}/src/dialectical_framework/dialectical_reasoning.py

@@ -166,8 +166,20 @@ class DialecticalReasoning(containers.DeclarativeContainer):
                     graph_db.execute(
                         "CREATE CONSTRAINT ON (n:Node) ASSERT n.hash, n.sid IS UNIQUE"
                     )
-            except Exception:
-                pass  # Constraint may already exist or DB doesn't support it
+            except Exception as e:
+                # Constraint may already exist or DB doesn't support it —
+                # but say so: this constraint is the only backstop against
+                # commit()'s check-then-act dedup race producing duplicate
+                # committed nodes under concurrent writers. Silent absence
+                # turns that race into silent corruption.
+                import logging
+
+                logging.getLogger(__name__).warning(
+                    "Could not create (hash, sid) uniqueness constraint: %s — "
+                    "duplicate-node protection is NOT active; ensure a single "
+                    "writer per sid.",
+                    e,
+                )
 
     # Graph database (Memgraph or Neo4j) for graph-native dialectical structures
     graph_db: providers.Singleton[Union[Memgraph, Neo4j]] = providers.Singleton(

dialectical_framework-1.7.1/src/dialectical_framework/exceptions/node_errors.py

@@ -0,0 +1,27 @@
+"""
+Node-related exceptions for the dialectical framework.
+"""
+
+from __future__ import annotations
+
+
+class ImmutableNodeError(Exception):
+    """Raised when attempting to modify a committed (immutable) node's structure."""
+
+
+class MissingScopeError(RuntimeError):
+    """Raised when an agent turn starts with no scope (sid) set.
+
+    Agent conversations (Analyst/Explorer/Advisor chat) write sid-scoped
+    nodes through their tools. Without `with scope(case.sid):` the turn
+    would fail SILENTLY: nodes save with sid=None, invisible to every
+    repository listing (work dropped while tool reports claim success),
+    and commit-time dedup falls back to an UNSCOPED find_by_hash that can
+    alias a node onto another Case's node, attaching foreign edges to it.
+
+    Deliberately an agent-level guard, not a BaseNode one: sid-less
+    "orphan" nodes are a supported node-layer semantic (portable
+    identifiers — see TestOrphanNodes), so programmatic callers may
+    create them; conversational turns never legitimately run unscoped.
+    """
+

{dialectical_framework-1.7.0 → dialectical_framework-1.7.1}/src/dialectical_framework/graph/nodes/decision.py

@@ -32,9 +32,12 @@ class Decision(IntentMixin, AssessableEntity, label="Decision"):
     Thin by design — the record points at the reasoning rather than
     restating it:
     - The question rides `intent` (IntentMixin); REQUIRED at commit.
-    - The distilled why is a Rationale node with agent="human" attached
-      via the standard EXPLAINS machinery (inherited `rationales`), which
-      also buys ratings/estimations/critiques on decisions.
+    - The distilled why is a Rationale attached via the standard EXPLAINS
+      machinery (inherited `rationales`), which also buys ratings/
+      estimations/critiques on decisions. Its `agent` names the confirming
+      principal: "human" iff a person confirmed the ceremony; a delegated
+      driver records "agent:<name>" (host-attested via
+      Advisor(principal=...), never LLM-supplied).
     - Grounds are GROUNDED_IN edges to committed nodes (perspectives,
       statements, wheels, transformations) with an optional role
       ("accepted_cost", "adopted_pathway", or None for a plain ground).

{dialectical_framework-1.7.0 → dialectical_framework-1.7.1}/src/dialectical_framework/graph/relationship_manager.py

@@ -1162,10 +1162,17 @@ class BoundRelationshipManager(Generic[T]):
         else:  # any
             pattern = f"(source)-[r:{self.relationship_type}]-(target:{resolved_labels})"
 
+        # Deterministic ordering: without ORDER BY, Cypher result order is
+        # unspecified (stable only by accident of current storage) — but
+        # consumers like build_pp_index treat this ordering as canonical
+        # (T1/T2 indices, cycle sequences). committed_at gives temporal
+        # order; id(target) tiebreaks same-second commits and uncommitted
+        # targets (NULL committed_at sorts consistently within a vendor).
         query = f"""
         MATCH {pattern}
         WHERE id(source) = $source_id
         RETURN target, r as relationship
+        ORDER BY target.committed_at ASC, id(target) ASC
         """
 
         results = db.execute_and_fetch(query, {"source_id": self.source_node._id})

{dialectical_framework-1.7.0 → dialectical_framework-1.7.1}/src/dialectical_framework/graph/repositories/cycle_repository.py

@@ -83,6 +83,7 @@ class CycleRepository:
                 AND size(c.perspective_hashes) = $hash_count
                 AND ALL(h IN $pp_hashes WHERE h IN c.perspective_hashes)
                 RETURN c
+                ORDER BY c.committed_at ASC, id(c) ASC
             """
             results = list(graph_db.execute_and_fetch(query, {
                 "sid": sid,
@@ -107,6 +108,7 @@ class CycleRepository:
                 WHERE c.sid = $sid
                 AND ANY(h IN $pp_hashes WHERE h IN c.perspective_hashes)
                 RETURN c
+                ORDER BY c.committed_at ASC, id(c) ASC
             """
             results = list(graph_db.execute_and_fetch(query, {
                 "sid": sid,
@@ -165,7 +167,7 @@ class CycleRepository:
             query += "    AND ALL(h IN c.perspective_hashes WHERE h IN $nexus_pp_hashes)\n"
             params["nexus_pp_hashes"] = nexus_pp_hashes
 
-        query += "    RETURN c"
+        query += "    RETURN c\n    ORDER BY c.committed_at ASC, id(c) ASC"
 
         results = list(graph_db.execute_and_fetch(query, params))
 

{dialectical_framework-1.7.0 → dialectical_framework-1.7.1}/src/dialectical_framework/graph/repositories/nexus_repository.py

@@ -82,6 +82,7 @@ class NexusRepository:
         query = """
         MATCH (n:Nexus {sid: $sid})
         RETURN n
+        ORDER BY n.committed_at ASC, id(n) ASC
         """
         results = list(graph_db.execute_and_fetch(query, {"sid": sid}))
         return [r["n"] for r in results]

{dialectical_framework-1.7.0 → dialectical_framework-1.7.1}/src/dialectical_framework/graph/repositories/wheel_repository.py

@@ -197,7 +197,7 @@ class WheelRepository:
             query += "    AND ALL(h IN c.perspective_hashes WHERE h IN $nexus_pp_hashes)\n"
             params["nexus_pp_hashes"] = nexus_pp_hashes
 
-        query += "    RETURN w"
+        query += "    RETURN w\n    ORDER BY w.committed_at ASC, id(w) ASC"
 
         results = list(graph_db.execute_and_fetch(query, params))
 

{dialectical_framework-1.7.0 → dialectical_framework-1.7.1}/src/dialectical_framework/graph/scope_context.py

@@ -33,6 +33,33 @@ _current_scope: contextvars.ContextVar[Optional[str]] = contextvars.ContextVar(
 )
 
 
+def require_current_sid() -> str:
+    """
+    Get the current scope ID (sid), raising if none is set.
+
+    Guard for entry points that must never run unscoped (agent chat
+    turns): running without scope fails silently otherwise — nodes save
+    with sid=None (invisible to every sid-scoped listing) and commit-time
+    dedup falls back to an unscoped lookup that can alias onto another
+    Case's nodes. Fail loud at the boundary instead.
+
+    Note: this is NOT enforced at the node layer — sid-less orphan nodes
+    are a supported semantic for programmatic callers (portable
+    identifiers). Only conversational entry points call this.
+    """
+    from dialectical_framework.exceptions.node_errors import \
+        MissingScopeError
+
+    sid = _current_scope.get()
+    if not sid:
+        raise MissingScopeError(
+            "No scope set for this agent turn. Wrap the call in "
+            "`with scope(case.sid):` — the framework never sets scope "
+            "itself, and running unscoped would silently drop all work."
+        )
+    return sid
+
+
 def get_current_sid() -> Optional[str]:
     """
     Get the current scope ID (sid) from context.

dialectical_framework-1.7.0/src/dialectical_framework/agents/advisor/tools/record_decision.py

@@ -1,62 +0,0 @@
-"""
-record_decision tool: persist a decision the person explicitly confirmed.
-
-The ceremony lives in conversation (propose → read back → confirm) — this
-tool is called only AFTER the person's explicit yes, with the confirmed
-wording passed literally. Retracting or replacing a recorded decision goes
-through the standard `discard` tool (reason referencing the new decision).
-"""
-
-from __future__ import annotations
-
-from typing import Annotated
-
-from mirascope import llm
-from pydantic import Field
-
-from dialectical_framework.concerns.record_decision import GroundLink
-
-
-@llm.tool
-async def record_decision(
-    question: Annotated[
-        str,
-        Field(description="The question that was being decided, in the person's confirmed words"),
-    ],
-    stance: Annotated[
-        str,
-        Field(description="The stance the person committed to, in their confirmed words"),
-    ],
-    rationale: Annotated[
-        str,
-        Field(
-            description="The distilled why behind the decision as the person confirmed it, "
-            "including reasons that live outside the mapped structure (deadlines, "
-            "people, external facts)"
-        ),
-    ],
-    grounds: Annotated[
-        list[GroundLink] | None,
-        Field(
-            description="Nodes this decision rests on: {hash, role?} each. "
-            "role='accepted_cost' for the unchosen side's contribution the person "
-            "confronted and accepted; role='adopted_pathway' for the pathway adopted "
-            "as the ongoing recipe; omit role for a plain ground (tensions weighed, "
-            "arrangements counseled from)."
-        ),
-    ] = None,
-) -> str:
-    """Record a decision the person has EXPLICITLY confirmed in conversation. Never call this silently or speculatively — propose the distilled record first, read it back, and record only on their clear yes. Links the decision to the graph nodes that grounded it and attaches the confirmed rationale. To replace or retract a recorded decision, use `discard` on it (with a reason naming the newer decision if one replaces it)."""
-    from dialectical_framework.concerns.record_decision import RecordDecision
-
-    # Mirascope passes json.loads'd kwargs without coercing nested models, so
-    # `grounds` arrives as raw dicts — RecordDecision.resolve normalizes them
-    # (single owner of that normalization) and refuses in-band on bad input.
-    concern = RecordDecision()
-    await concern.resolve(
-        question=question,
-        stance=stance,
-        rationale=rationale,
-        grounds=grounds,
-    )
-    return str(concern.report)

dialectical_framework-1.7.0/src/dialectical_framework/exceptions/node_errors.py

@@ -1,10 +0,0 @@
-"""
-Node-related exceptions for the dialectical framework.
-"""
-
-from __future__ import annotations
-
-
-class ImmutableNodeError(Exception):
-    """Raised when attempting to modify a committed (immutable) node's structure."""
-