trinity-agent 0.2.1__tar.gz → 0.3.0__tar.gz

{trinity_agent-0.2.1 → trinity_agent-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trinity-agent
-Version: 0.2.1
+Version: 0.3.0
 Summary: Three minds, one context — Multi-agent AI orchestrator for Claude Code, Codex, and Gemini CLI.
 Project-URL: Homepage, https://github.com/hongdangmoo49/Trinity
 Project-URL: Repository, https://github.com/hongdangmoo49/Trinity

{trinity_agent-0.2.1 → trinity_agent-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "trinity-agent"
-version = "0.2.1"
+version = "0.3.0"
 description = "Three minds, one context — Multi-agent AI orchestrator for Claude Code, Codex, and Gemini CLI."
 readme = "README.md"
 requires-python = ">=3.10"

{trinity_agent-0.2.1 → trinity_agent-0.3.0}/src/trinity/__init__.py

@@ -1,3 +1,3 @@
 """Trinity — Three minds, one context."""
 
-__version__ = "0.2.1"
+__version__ = "0.3.0"

{trinity_agent-0.2.1 → trinity_agent-0.3.0}/src/trinity/cli.py

@@ -45,11 +45,16 @@ def find_config_path() -> Path | None:
     return None
 
 
-def load_config() -> TrinityConfig:
-    """Load config from file or return default."""
+def load_config(silent: bool = False) -> TrinityConfig:
+    """Load config from file or return default.
+
+    Args:
+        silent: If True, suppress the "Loaded config from..." message.
+    """
     config_path = find_config_path()
     if config_path:
-        console.print(f"[dim]Loaded config from {config_path}[/dim]")
+        if not silent:
+            console.print(f"[dim]Loaded config from {config_path}[/dim]")
         return TrinityConfig.load(config_path)
     return TrinityConfig.default_config()
 
@@ -78,7 +83,7 @@ def _run_interactive_tui() -> None:
     """Launch the interactive TUI session."""
     from trinity.tui.session import InteractiveSession
 
-    config = load_config()
+    config = load_config(silent=True)
 
     # If no .trinity/ directory exists, suggest running init first
     state_dir = config.effective_state_dir

{trinity_agent-0.2.1 → trinity_agent-0.3.0}/src/trinity/deliberation/consensus.py

@@ -163,9 +163,41 @@ class ConsensusEngine:
     ) -> str:
         """Build a human-readable consensus summary."""
         if reached:
+            # Extract key content from opinions for a meaningful summary
+            key_points = self._extract_key_points(opinions)
+            if key_points:
+                return (
+                    f"Consensus reached ({len(agreeing)}/{len(opinions)} agree). "
+                    f"Key points: {key_points}"
+                )
             return f"Consensus reached. Agreeing: {', '.join(agreeing)}."
         else:
             return (
                 f"Consensus not reached ({len(agreeing)}/{len(opinions)} agree). "
                 f"Need another round of deliberation."
             )
+
+    def _extract_key_points(self, opinions: dict[str, str]) -> str:
+        """Extract key points from agent opinions for summary.
+
+        Takes the first opinion and truncates to a reasonable length.
+        """
+        if not opinions:
+            return ""
+
+        # Use the first opinion as representative
+        for text in opinions.values():
+            # Clean and truncate
+            clean = text.strip()
+            # Take first meaningful sentence(s), up to 200 chars
+            if len(clean) > 200:
+                # Truncate at last sentence boundary within limit
+                truncated = clean[:200]
+                last_period = truncated.rfind(".")
+                if last_period > 50:
+                    clean = truncated[: last_period + 1]
+                else:
+                    clean = truncated + "..."
+            return clean
+
+        return ""

{trinity_agent-0.2.1 → trinity_agent-0.3.0}/src/trinity/deliberation/distributor.py

@@ -94,16 +94,15 @@ class TaskDistributor:
         if matched_strengths:
             strengths_text = ", ".join(matched_strengths)
             task_desc = (
-                f"Based on the agreed conclusion, handle: {strengths_text}. "
-                f"The consensus is: {consensus[:200]}. "
-                f"Focus on your strengths in {strengths_text} and deliver concrete output."
+                f"[{agent_name}] Handle: {strengths_text}. "
+                f"Consensus: {consensus[:150]}"
             )
         else:
-            # No specific strength matched — assign a general task
+            # No specific strength matched — assign based on role
+            role_short = role.split(".")[0] if "." in role else role[:50]
             task_desc = (
-                f"Based on the agreed conclusion, contribute to implementation. "
-                f"The consensus is: {consensus[:200]}. "
-                f"Identify what you can best contribute and execute."
+                f"[{agent_name}] As {role_short}, execute on the agreed conclusion. "
+                f"Consensus: {consensus[:100]}"
             )
 
         return TaskAssignment(

{trinity_agent-0.2.1 → trinity_agent-0.3.0}/src/trinity/deliberation/protocol.py

@@ -1,218 +1,291 @@
-"""Deliberation protocol — round-based deliberation loop."""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-import time
-
-from trinity.agents.base import AgentWrapper
-from trinity.context.shared import SharedContextEngine
-from trinity.deliberation.consensus import ConsensusEngine
-from trinity.deliberation.distributor import TaskDistributor
-from trinity.models import (
-    ConsensusResult,
-    DeliberationMessage,
-    DeliberationResult,
-    MessageRole,
-    TaskAssignment,
-)
-
-logger = logging.getLogger(__name__)
-
-
-class DeliberationProtocol:
-    """Round-based deliberation: opinions → counter → consensus → tasks.
-
-    Each round:
-    1. Build a round-specific prompt for all agents
-    2. Send to all agents in parallel (asyncio.gather)
-    3. Collect responses → write to shared.md
-    4. Check for consensus
-    5. If reached, distribute tasks. Otherwise, next round.
-    """
-
-    def __init__(
-        self,
-        agents: dict[str, AgentWrapper],
-        shared: SharedContextEngine,
-        consensus_engine: ConsensusEngine | None = None,
-        distributor: TaskDistributor | None = None,
-        max_rounds: int = 5,
-        round_timeout: float = 120.0,
-        tmux_manager=None,
-    ):
-        self.agents = agents
-        self.shared = shared
-        self.consensus_engine = consensus_engine or ConsensusEngine()
-        self.distributor = distributor or TaskDistributor()
-        self.max_rounds = max_rounds
-        self.round_timeout = round_timeout
-        self.tmux_manager = tmux_manager
-
-    async def run(self, user_prompt: str) -> DeliberationResult:
-        """Execute full deliberation loop."""
-        start_time = time.time()
-        agent_names = list(self.agents.keys())
-
-        # Initialize shared.md
-        self.shared.initialize(goal=user_prompt, agent_names=agent_names)
-
-        consensus: ConsensusResult | None = None
-        round_num = 0
-
-        for round_num in range(1, self.max_rounds + 1):
-            logger.info(f"=== Round {round_num}/{self.max_rounds} ===")
-
-            # Update tmux pane titles to show round progress
-            self._update_pane_titles(f"Round {round_num}/{self.max_rounds}")
-
-            # Build prompt for this round
-            round_prompt = self._build_round_prompt(round_num, user_prompt)
-
-            # Collect opinions from all agents in parallel
-            opinions = await self._collect_opinions(round_num, round_prompt)
-
-            # Write opinions to shared.md
-            for name, msg in opinions.items():
-                self.shared.append_opinion(name, round_num, msg.content)
-
-            # Update message round_num (it was set to 0 in agent)
-            for name, msg in opinions.items():
-                msg.round_num = round_num
-
-            # Check consensus
-            opinion_texts = {name: msg.content for name, msg in opinions.items()}
-            consensus = self.consensus_engine.evaluate(opinion_texts)
-
-            if consensus.reached:
-                logger.info(f"Consensus reached at round {round_num}!")
-                self.shared.update_consensus(consensus.summary)
-                self._update_pane_titles("✓ Consensus!")
-                break
-
-            logger.info(f"No consensus yet. Continuing to round {round_num + 1}.")
-
-        # Update pane titles for task distribution phase
-        self._update_pane_titles("Distributing tasks...")
-
-        # If no consensus after all rounds, force conclusion
-        if consensus and not consensus.reached:
-            logger.warning(f"Max rounds ({self.max_rounds}) reached. Forcing conclusion.")
-            consensus = ConsensusResult(
-                reached=True,  # Force it
-                agreement_count=consensus.agreement_count,
-                total_agents=consensus.total_agents,
-                opinions=consensus.opinions,
-                summary=f"Forced conclusion after {self.max_rounds} rounds. "
-                f"Majority opinion selected.",
-            )
-            self.shared.update_consensus(consensus.summary)
-
-        # Distribute tasks
-        tasks = self.distributor.distribute(
-            consensus_text=consensus.summary if consensus else user_prompt,
-            agents={name: ag.spec for name, ag in self.agents.items()},
-        )
-
-        # Write tasks to shared.md
-        task_dict = {t.agent_name: t.task_description for t in tasks}
-        self.shared.update_tasks(task_dict)
-
-        # Calculate totals
-        total_tokens = sum(
-            ag.context_usage.used for ag in self.agents.values()
-        )
-        elapsed = time.time() - start_time
-
-        return DeliberationResult(
-            user_prompt=user_prompt,
-            rounds_completed=round_num,
-            consensus=consensus,
-            tasks=tasks,
-            total_tokens_used=total_tokens,
-            duration_seconds=elapsed,
-        )
-
-    async def _collect_opinions(
-        self, round_num: int, prompt: str
-    ) -> dict[str, DeliberationMessage]:
-        """Send prompt to all agents in parallel and collect responses."""
-        tasks = {
-            name: agent.send_and_wait(prompt, timeout=self.round_timeout)
-            for name, agent in self.agents.items()
-        }
-
-        results = await asyncio.gather(
-            *tasks.values(), return_exceptions=True
-        )
-
-        opinions: dict[str, DeliberationMessage] = {}
-        for name, result in zip(tasks.keys(), results):
-            if isinstance(result, Exception):
-                logger.error(f"[{name}] Error in round {round_num}: {result}")
-                opinions[name] = DeliberationMessage(
-                    source=name,
-                    target="all",
-                    round_num=round_num,
-                    role=MessageRole.OPINION,
-                    content=f"[Error: {result}]",
-                )
-            elif isinstance(result, DeliberationMessage):
-                result.round_num = round_num
-                opinions[name] = result
-            else:
-                logger.warning(f"[{name}] Unexpected result type: {type(result)}")
-
-        return opinions
-
-    def _build_round_prompt(self, round_num: int, user_prompt: str) -> str:
-        """Build the prompt for a specific deliberation round."""
-        if round_num == 1:
-            return (
-                f"Read the shared context below for background.\n\n"
-                f"User's request: {user_prompt}\n\n"
-                f"Share your initial opinion. Be specific and concise.\n"
-                f"State your recommendation and key reasoning.\n"
-                f"Keep your response under 500 words."
-            )
-        else:
-            # Read previous round opinions from shared.md
-            prev_section = self.shared.read_section(f"Round {round_num - 1} Opinions")
-            prev_context = prev_section or "(previous round opinions not available)"
-
-            return (
-                f"Previous round opinions:\n\n"
-                f"{prev_context}\n\n"
-                f"---\n\n"
-                f"For each other agent's opinion above, state whether you AGREE or DISAGREE "
-                f"and explain why. If you disagree, propose an alternative.\n"
-                f"End your response with either 'I AGREE with [name]' or your counter-proposal.\n"
-                f"Keep your response under 300 words."
-            )
-
-    def _update_pane_titles(self, status_text: str) -> None:
-        """Update tmux pane titles to show round progress (Phase 2 feature)."""
-        if not self.tmux_manager:
-            return
-
-        import subprocess
-
-        for name in self.agents:
-            pane = self.tmux_manager.get_pane(name)
-            if pane:
-                try:
-                    subprocess.run(
-                        [
-                            "tmux",
-                            "select-pane",
-                            "-t",
-                            pane.pane_id,
-                            "-T",
-                            f"{name}: {status_text}",
-                        ],
-                        capture_output=True,
-                        timeout=5,
-                    )
-                except Exception:
-                    pass  # Non-critical — don't fail deliberation for title update
+"""Deliberation protocol — round-based deliberation loop."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import time
+from typing import Callable
+
+from trinity.agents.base import AgentWrapper
+from trinity.context.shared import SharedContextEngine
+from trinity.deliberation.consensus import ConsensusEngine
+from trinity.deliberation.distributor import TaskDistributor
+from trinity.models import (
+    ConsensusResult,
+    DeliberationMessage,
+    DeliberationResult,
+    MessageRole,
+    TaskAssignment,
+)
+from trinity.tui.events import TUIEvent, TUIEventType
+
+logger = logging.getLogger(__name__)
+
+
+class DeliberationProtocol:
+    """Round-based deliberation: opinions → counter → consensus → tasks.
+
+    Each round:
+    1. Build a round-specific prompt for all agents
+    2. Send to all agents in parallel (with per-agent completion streaming)
+    3. Collect responses → write to shared.md
+    4. Check for consensus
+    5. If reached, distribute tasks. Otherwise, next round.
+
+    When an event_callback is provided, events are emitted for each
+    agent completion, round transition, and consensus evaluation,
+    enabling real-time TUI updates.
+    """
+
+    def __init__(
+        self,
+        agents: dict[str, AgentWrapper],
+        shared: SharedContextEngine,
+        consensus_engine: ConsensusEngine | None = None,
+        distributor: TaskDistributor | None = None,
+        max_rounds: int = 5,
+        round_timeout: float = 120.0,
+        tmux_manager=None,
+        event_callback: Callable[[TUIEvent], None] | None = None,
+    ):
+        self.agents = agents
+        self.shared = shared
+        self.consensus_engine = consensus_engine or ConsensusEngine()
+        self.distributor = distributor or TaskDistributor()
+        self.max_rounds = max_rounds
+        self.round_timeout = round_timeout
+        self.tmux_manager = tmux_manager
+        self._event_callback = event_callback
+
+    def _emit(self, event_type: TUIEventType, **kwargs) -> None:
+        """Emit a TUI event if callback is registered."""
+        if self._event_callback:
+            self._event_callback(TUIEvent(type=event_type, data=kwargs))
+
+    async def run(self, user_prompt: str) -> DeliberationResult:
+        """Execute full deliberation loop."""
+        start_time = time.time()
+        agent_names = list(self.agents.keys())
+
+        # Initialize shared.md
+        self.shared.initialize(goal=user_prompt, agent_names=agent_names)
+
+        consensus: ConsensusResult | None = None
+        round_num = 0
+
+        for round_num in range(1, self.max_rounds + 1):
+            logger.info(f"=== Round {round_num}/{self.max_rounds} ===")
+
+            # Emit round start
+            self._emit(TUIEventType.ROUND_START, round_num=round_num)
+
+            # Update tmux pane titles to show round progress
+            self._update_pane_titles(f"Round {round_num}/{self.max_rounds}")
+
+            # Build prompt for this round
+            round_prompt = self._build_round_prompt(round_num, user_prompt)
+
+            # Collect opinions from all agents (with per-agent streaming)
+            opinions = await self._collect_opinions(round_num, round_prompt)
+
+            # Write opinions to shared.md
+            for name, msg in opinions.items():
+                self.shared.append_opinion(name, round_num, msg.content)
+
+            # Update message round_num (it was set to 0 in agent)
+            for name, msg in opinions.items():
+                msg.round_num = round_num
+
+            # Check consensus
+            self._emit(TUIEventType.CONSENSUS_CHECKING, round_num=round_num)
+
+            opinion_texts = {name: msg.content for name, msg in opinions.items()}
+            consensus = self.consensus_engine.evaluate(opinion_texts)
+
+            if consensus.reached:
+                logger.info(f"Consensus reached at round {round_num}!")
+                self.shared.update_consensus(consensus.summary)
+                self._update_pane_titles("✓ Consensus!")
+
+                self._emit(
+                    TUIEventType.CONSENSUS_RESULT,
+                    reached=True,
+                    agreement_count=consensus.agreement_count,
+                    total_agents=consensus.total_agents,
+                    summary=consensus.summary,
+                    round_num=round_num,
+                )
+                break
+
+            logger.info(f"No consensus yet. Continuing to round {round_num + 1}.")
+
+            self._emit(
+                TUIEventType.CONSENSUS_RESULT,
+                reached=False,
+                agreement_count=consensus.agreement_count,
+                total_agents=consensus.total_agents,
+                summary="",
+                round_num=round_num,
+            )
+
+        # Update pane titles for task distribution phase
+        self._update_pane_titles("Distributing tasks...")
+
+        # If no consensus after all rounds, force conclusion
+        if consensus and not consensus.reached:
+            logger.warning(f"Max rounds ({self.max_rounds}) reached. Forcing conclusion.")
+            consensus = ConsensusResult(
+                reached=True,  # Force it
+                agreement_count=consensus.agreement_count,
+                total_agents=consensus.total_agents,
+                opinions=consensus.opinions,
+                summary=f"Forced conclusion after {self.max_rounds} rounds. "
+                f"Majority opinion selected.",
+            )
+            self.shared.update_consensus(consensus.summary)
+
+        # Distribute tasks
+        tasks = self.distributor.distribute(
+            consensus_text=consensus.summary if consensus else user_prompt,
+            agents={name: ag.spec for name, ag in self.agents.items()},
+        )
+
+        # Write tasks to shared.md
+        task_dict = {t.agent_name: t.task_description for t in tasks}
+        self.shared.update_tasks(task_dict)
+
+        # Calculate totals
+        total_tokens = sum(
+            ag.context_usage.used for ag in self.agents.values()
+        )
+        elapsed = time.time() - start_time
+
+        self._emit(TUIEventType.DELIBERATION_DONE)
+
+        return DeliberationResult(
+            user_prompt=user_prompt,
+            rounds_completed=round_num,
+            consensus=consensus,
+            tasks=tasks,
+            total_tokens_used=total_tokens,
+            duration_seconds=elapsed,
+        )
+
+    async def _collect_opinions(
+        self, round_num: int, prompt: str
+    ) -> dict[str, DeliberationMessage]:
+        """Send prompt to all agents in parallel and collect responses.
+
+        Uses asyncio.wait(FIRST_COMPLETED) instead of asyncio.gather
+        to enable per-agent completion streaming via events.
+        """
+        # Create tasks with agent names attached
+        pending: set[asyncio.Task] = set()
+        task_to_name: dict[asyncio.Task, str] = {}
+
+        for name, agent in self.agents.items():
+            coro = agent.send_and_wait(prompt, timeout=self.round_timeout)
+            task = asyncio.ensure_future(coro)
+            task_to_name[task] = name
+            pending.add(task)
+            self._emit(TUIEventType.AGENT_THINKING, agent=name, round_num=round_num)
+
+        opinions: dict[str, DeliberationMessage] = {}
+
+        while pending:
+            done, pending = await asyncio.wait(
+                pending, return_when=asyncio.FIRST_COMPLETED
+            )
+
+            for task in done:
+                name = task_to_name[task]
+                try:
+                    result = task.result()
+                except Exception as exc:
+                    logger.error(f"[{name}] Error in round {round_num}: {exc}")
+                    opinions[name] = DeliberationMessage(
+                        source=name,
+                        target="all",
+                        round_num=round_num,
+                        role=MessageRole.OPINION,
+                        content=f"[Error: {exc}]",
+                    )
+                    self._emit(
+                        TUIEventType.AGENT_ERROR,
+                        agent=name,
+                        error=str(exc),
+                        round_num=round_num,
+                    )
+                    continue
+
+                if isinstance(result, DeliberationMessage):
+                    result.round_num = round_num
+                    opinions[name] = result
+                    self._emit(
+                        TUIEventType.AGENT_RESPONDED,
+                        agent=name,
+                        content=result.content,
+                        round_num=round_num,
+                    )
+                else:
+                    logger.warning(f"[{name}] Unexpected result type: {type(result)}")
+                    self._emit(
+                        TUIEventType.AGENT_ERROR,
+                        agent=name,
+                        error=f"Unexpected result type: {type(result)}",
+                        round_num=round_num,
+                    )
+
+        return opinions
+
+    def _build_round_prompt(self, round_num: int, user_prompt: str) -> str:
+        """Build the prompt for a specific deliberation round."""
+        if round_num == 1:
+            return (
+                f"Read the shared context below for background.\n\n"
+                f"User's request: {user_prompt}\n\n"
+                f"Share your initial opinion. Be specific and concise.\n"
+                f"State your recommendation and key reasoning.\n"
+                f"Keep your response under 500 words."
+            )
+        else:
+            # Read previous round opinions from shared.md
+            prev_section = self.shared.read_section(f"Round {round_num - 1} Opinions")
+            prev_context = prev_section or "(previous round opinions not available)"
+
+            return (
+                f"Previous round opinions:\n\n"
+                f"{prev_context}\n\n"
+                f"---\n\n"
+                f"For each other agent's opinion above, state whether you AGREE or DISAGREE "
+                f"and explain why. If you disagree, propose an alternative.\n"
+                f"End your response with either 'I AGREE with [name]' or your counter-proposal.\n"
+                f"Keep your response under 300 words."
+            )
+
+    def _update_pane_titles(self, status_text: str) -> None:
+        """Update tmux pane titles to show round progress (Phase 2 feature)."""
+        if not self.tmux_manager:
+            return
+
+        import subprocess
+
+        for name in self.agents:
+            pane = self.tmux_manager.get_pane(name)
+            if pane:
+                try:
+                    subprocess.run(
+                        [
+                            "tmux",
+                            "select-pane",
+                            "-t",
+                            pane.pane_id,
+                            "-T",
+                            f"{name}: {status_text}",
+                        ],
+                        capture_output=True,
+                        timeout=5,
+                    )
+                except Exception:
+                    pass  # Non-critical — don't fail deliberation for title update