trinity-lite 0.2.3__tar.gz → 0.4.0__tar.gz

{trinity_lite-0.2.3/trinity_lite.egg-info → trinity_lite-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trinity-lite
-Version: 0.2.3
+Version: 0.4.0
 Summary: The bus that lets your AI agents talk to each other.
 Author: Yomiracle
 License-Expression: MIT
@@ -86,6 +86,7 @@ LangGraph and CrewAI give you primitives for building agents from scratch — gr
 - **Check health in one pass.** `trinity-lite doctor` verifies Python, SQLite, route config, agent config, and publish readiness.
 - **Zero dependencies.** Runtime is Python standard library only. Nothing to install but Python 3.10+.
 - **109 tests guarding the surface area.** Mock workflows, safety checks, routing, persistence — all covered.
+- **Smart model selection.** Automatically picks the right LLM for each task. Simple CRUD → cheap model. Architecture design → strong reasoning model. Define your own model pool with tiers and strength tags.
 
 ## Install
 
@@ -153,6 +154,48 @@ trinity-lite mcp serve
 
 **3 resources:** `trinity://health`, `trinity://tasks/recent`, `trinity://tasks/{task_id}`
 
+## Model Selector (NEW in v0.4.0)
+
+Auto-pick the best LLM for each task based on complexity:
+
+```bash
+# Auto-detect your available models (zero config)
+trinity-lite detect-models
+
+# Or set up interactively (no JSON needed)
+trinity-lite setup-models
+```
+
+**How it works**: Define your model pool with tiers (`budget` / `standard` / `premium`) and strength tags. The selector picks automatically:
+
+| Task | → Tier | → Model |
+|---|---|---|
+| "Fix typo in README" | budget | cheap model |
+| "Add search endpoint" | budget | cheap model |
+| "Refactor auth module" | standard | mid-tier |
+| "Design microservice architecture" | premium | strongest |
+
+**Manual call** (API usage):
+
+```python
+from trinity_lite.model_selector import select_model
+
+result = select_model("Design a rate limiter", task_type="architecture_design")
+print(result["model"])  # → gpt-5.5
+print(result["reason"]) # → hard_signal:architecture
+```
+
+**Custom pool** — create `~/.trinity/model_pool.json`:
+
+```json
+{
+  "your-cheap-model": {"tier": "budget", "strengths": ["coding"], "api_type": "anthropic"},
+  "your-strong-model": {"tier": "premium", "strengths": ["reasoning", "architecture"], "api_type": "openai"}
+}
+```
+
+Works with 1 model, 2 models, or 10 models. No agent names hardcoded.
+
 ## Links
 
 - [PyPI](https://pypi.org/project/trinity-lite/)

{trinity_lite-0.2.3 → trinity_lite-0.4.0}/README.md

@@ -61,6 +61,7 @@ LangGraph and CrewAI give you primitives for building agents from scratch — gr
 - **Check health in one pass.** `trinity-lite doctor` verifies Python, SQLite, route config, agent config, and publish readiness.
 - **Zero dependencies.** Runtime is Python standard library only. Nothing to install but Python 3.10+.
 - **109 tests guarding the surface area.** Mock workflows, safety checks, routing, persistence — all covered.
+- **Smart model selection.** Automatically picks the right LLM for each task. Simple CRUD → cheap model. Architecture design → strong reasoning model. Define your own model pool with tiers and strength tags.
 
 ## Install
 
@@ -128,6 +129,48 @@ trinity-lite mcp serve
 
 **3 resources:** `trinity://health`, `trinity://tasks/recent`, `trinity://tasks/{task_id}`
 
+## Model Selector (NEW in v0.4.0)
+
+Auto-pick the best LLM for each task based on complexity:
+
+```bash
+# Auto-detect your available models (zero config)
+trinity-lite detect-models
+
+# Or set up interactively (no JSON needed)
+trinity-lite setup-models
+```
+
+**How it works**: Define your model pool with tiers (`budget` / `standard` / `premium`) and strength tags. The selector picks automatically:
+
+| Task | → Tier | → Model |
+|---|---|---|
+| "Fix typo in README" | budget | cheap model |
+| "Add search endpoint" | budget | cheap model |
+| "Refactor auth module" | standard | mid-tier |
+| "Design microservice architecture" | premium | strongest |
+
+**Manual call** (API usage):
+
+```python
+from trinity_lite.model_selector import select_model
+
+result = select_model("Design a rate limiter", task_type="architecture_design")
+print(result["model"])  # → gpt-5.5
+print(result["reason"]) # → hard_signal:architecture
+```
+
+**Custom pool** — create `~/.trinity/model_pool.json`:
+
+```json
+{
+  "your-cheap-model": {"tier": "budget", "strengths": ["coding"], "api_type": "anthropic"},
+  "your-strong-model": {"tier": "premium", "strengths": ["reasoning", "architecture"], "api_type": "openai"}
+}
+```
+
+Works with 1 model, 2 models, or 10 models. No agent names hardcoded.
+
 ## Links
 
 - [PyPI](https://pypi.org/project/trinity-lite/)

{trinity_lite-0.2.3 → trinity_lite-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "trinity-lite"
-version = "0.2.3"
+version = "0.4.0"
 description = "The bus that lets your AI agents talk to each other."
 readme = "README.md"
 requires-python = ">=3.10"

{trinity_lite-0.2.3 → trinity_lite-0.4.0}/tests/test_mcp_server.py

@@ -68,7 +68,7 @@ class McpServerTest(unittest.TestCase):
         self.assertIn("resources", resp["result"]["capabilities"])
         self.assertIn("serverInfo", resp["result"])
         self.assertEqual(resp["result"]["serverInfo"]["name"], "trinity-lite-mcp")
-        self.assertEqual(resp["result"]["serverInfo"]["version"], "0.2.2")
+        self.assertEqual(resp["result"]["serverInfo"]["version"], "0.3.1")
 
     def test_initialized_returns_none(self):
         resp = self._call(self._msg("initialized"))
@@ -90,7 +90,7 @@ class McpServerTest(unittest.TestCase):
         resp = self._call(self._msg("tools/list", 1))
         tools = resp["result"]["tools"]
         self.assertIsInstance(tools, list)
-        self.assertEqual(len(tools), 10)
+        self.assertEqual(len(tools), 12)
         names = [t["name"] for t in tools]
         self.assertIn("trinity_dispatch", names)
         self.assertIn("trinity_dispatch_auto", names)
@@ -133,7 +133,7 @@ class McpServerTest(unittest.TestCase):
         data = json.loads(contents[0]["text"])
         self.assertEqual(data["status"], "ok")
         self.assertEqual(data["bus"], "connected")
-        self.assertEqual(data["tools"], 10)
+        self.assertEqual(data["tools"], 12)
         self.assertEqual(data["resources"], 3)
 
     def test_resource_health_degraded(self):

trinity_lite-0.4.0/tests/test_pipeline.py

@@ -0,0 +1,185 @@
+"""Tests for pipeline orchestration."""
+
+import json
+import tempfile
+import unittest
+from pathlib import Path
+
+from trinity_lite.bus import TrinityBus
+from trinity_lite.pipeline import (
+    load_pipeline,
+    resolve_step_prompt,
+    run_pipeline,
+)
+
+
+class PipelineTest(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory(dir=str(Path.home()))
+        self.root = Path(self.tmp.name)
+
+    def tearDown(self):
+        self.tmp.cleanup()
+
+    def _write_yaml(self, name, content):
+        path = self.root / name
+        path.write_text(content, encoding="utf-8")
+        return str(path)
+
+    def test_load_valid_pipeline(self):
+        yaml_text = "name: test-pipeline\nsteps:\n  - id: step1\n    agent: codex\n    task_type: implementation\n    prompt_template: 'Implement: {task}'\n"
+        yaml_path = self._write_yaml("test.yaml", yaml_text)
+        p = load_pipeline(yaml_path)
+        self.assertEqual(p["name"], "test-pipeline")
+        self.assertEqual(len(p["steps"]), 1)
+        self.assertEqual(p["steps"][0]["id"], "step1")
+
+    def test_load_invalid_yaml_raises(self):
+        json_path = self._write_yaml("bad.json", "not valid json{{{")
+        with self.assertRaises(ValueError):
+            load_pipeline(json_path)
+
+    def test_missing_required_field_raises(self):
+        yaml_text = "name: bad\nsteps:\n  - id: step1\n    task_type: implementation\n    prompt_template: 'ok'\n"
+        yaml_path = self._write_yaml("bad.yaml", yaml_text)
+        with self.assertRaises(ValueError):
+            load_pipeline(yaml_path)
+
+    def test_empty_steps_raises(self):
+        yaml_path = self._write_yaml("empty.yaml", "name: empty\nsteps: []")
+        with self.assertRaises(ValueError):
+            load_pipeline(yaml_path)
+
+    def test_duplicate_step_ids_raises(self):
+        yaml_text = "name: dup\nsteps:\n  - id: step1\n    agent: codex\n    task_type: implementation\n    prompt_template: 'ok'\n  - id: step1\n    agent: codex\n    task_type: implementation\n    prompt_template: 'ok'\n"
+        yaml_path = self._write_yaml("dup.yaml", yaml_text)
+        with self.assertRaises(ValueError):
+            load_pipeline(yaml_path)
+
+    def test_unknown_step_reference_raises(self):
+        yaml_text = "name: badref\nsteps:\n  - id: step1\n    agent: codex\n    task_type: implementation\n    prompt_template: 'Result: {steps.nonexistent.result}'\n"
+        yaml_path = self._write_yaml("badref.yaml", yaml_text)
+        with self.assertRaises(ValueError):
+            load_pipeline(yaml_path)
+
+    def test_prompt_template_rendering_task_only(self):
+        step = {"prompt_template": "Do: {task}"}
+        result = resolve_step_prompt(step, "write tests", {})
+        self.assertEqual(result, "Do: write tests")
+
+    def test_prompt_template_rendering_with_step_result(self):
+        step = {"prompt_template": "Result was: {steps.step1.result}"}
+        step_results = {"step1": {"result": "all done", "status": "completed"}}
+        result = resolve_step_prompt(step, "task", step_results)
+        self.assertEqual(result, "Result was: all done")
+
+    def test_prompt_template_rendering_with_missing_step(self):
+        step = {"prompt_template": "Got: {steps.missing.result}"}
+        result = resolve_step_prompt(step, "task", {})
+        self.assertEqual(result, "Got: ")
+
+    def test_prompt_template_rendering_with_error(self):
+        step = {"prompt_template": "Error: {steps.step1.result}"}
+        step_results = {"step1": {"error": "failed hard", "status": "failed"}}
+        result = resolve_step_prompt(step, "task", step_results)
+        self.assertEqual(result, "Error: failed hard")
+
+    def test_run_single_step_pipeline(self):
+        bus = TrinityBus(self.root / "bus.db", allowed_roots=[self.root])
+        pipeline = {
+            "name": "test-single",
+            "steps": [
+                {"id": "implement", "agent": "codex", "task_type": "implementation",
+                 "prompt_template": "Implement: {task}"}
+            ],
+        }
+        result = run_pipeline(pipeline, "hello world", bus, cwd=str(self.root))
+        self.assertEqual(result["pipeline_name"], "test-single")
+        self.assertEqual(result["overall_status"], "completed")
+        self.assertEqual(len(result["steps"]), 1)
+        self.assertEqual(result["steps"][0]["status"], "completed")
+
+    def test_run_two_step_pipeline(self):
+        bus = TrinityBus(self.root / "bus.db", allowed_roots=[self.root])
+        pipeline = {
+            "name": "test-two",
+            "steps": [
+                {"id": "implement", "agent": "codex", "task_type": "implementation",
+                 "prompt_template": "Implement: {task}"},
+                {"id": "review", "agent": "claude_code", "task_type": "code_review",
+                 "prompt_template": "Review: {task}\nResult: {steps.implement.result}"},
+            ],
+        }
+        result = run_pipeline(pipeline, "hello", bus, cwd=str(self.root))
+        self.assertEqual(result["overall_status"], "completed")
+        self.assertEqual(len(result["steps"]), 2)
+        self.assertEqual(result["steps"][0]["status"], "completed")
+        self.assertEqual(result["steps"][1]["status"], "completed")
+
+    def test_pipeline_step_results_accessible(self):
+        bus = TrinityBus(self.root / "bus.db", allowed_roots=[self.root])
+        pipeline = {
+            "name": "test-ref",
+            "steps": [
+                {"id": "step1", "agent": "codex", "task_type": "implementation",
+                 "prompt_template": "Task: {task}"},
+                {"id": "step2", "agent": "claude_code", "task_type": "code_review",
+                 "prompt_template": "Previous result was: {steps.step1.result}"},
+            ],
+        }
+        result = run_pipeline(pipeline, "check refs", bus, cwd=str(self.root))
+        self.assertEqual(result["overall_status"], "completed")
+        step2 = bus.get_task(result["steps"][1]["task_id"])
+        self.assertIn("Previous result was:", step2["prompt"])
+
+    def test_pipeline_no_run_workers(self):
+        bus = TrinityBus(self.root / "bus.db", allowed_roots=[self.root])
+        pipeline = {
+            "name": "test-no-run",
+            "steps": [
+                {"id": "step1", "agent": "codex", "task_type": "implementation",
+                 "prompt_template": "{task}"}
+            ],
+        }
+        result = run_pipeline(pipeline, "stuff", bus, cwd=str(self.root), run_workers=False)
+        self.assertEqual(result["overall_status"], "queued")
+
+    def test_pipeline_fail_fast(self):
+        bus = TrinityBus(self.root / "bus.db", allowed_roots=[self.root])
+        pipeline = {
+            "name": "test-fail",
+            "steps": [
+                {"id": "step1", "agent": "no_such_agent", "task_type": "implementation",
+                 "prompt_template": "{task}"},
+                {"id": "step2", "agent": "codex", "task_type": "implementation",
+                 "prompt_template": "{task}"},
+            ],
+        }
+        result = run_pipeline(pipeline, "stuff", bus, cwd=str(self.root))
+        self.assertEqual(result["overall_status"], "failed")
+        self.assertEqual(len(result["steps"]), 1)
+
+    def test_cli_orchestrate_with_pipeline_flag(self):
+        import io as _io
+        import json as _json
+        from contextlib import redirect_stdout as _redirect_stdout
+        from trinity_lite.cli import main
+        yaml_text = "name: cli-pipe\nsteps:\n  - id: step1\n    agent: codex\n    task_type: implementation\n    prompt_template: 'ok'\n"
+        pipeline_path = self._write_yaml("cli_test.yaml", yaml_text)
+        output = _io.StringIO()
+        with _redirect_stdout(output):
+            code = main([
+                "orchestrate",
+                "test task",
+                "--pipeline", pipeline_path,
+                "--db", str(self.root / "cli_bus.db"),
+                "--cwd", str(self.root),
+            ])
+        self.assertEqual(code, 0)
+        data = _json.loads(output.getvalue())
+        self.assertEqual(data["pipeline_name"], "cli-pipe")
+        self.assertEqual(data["overall_status"], "completed")
+
+
+if __name__ == "__main__":
+    unittest.main()

trinity_lite-0.4.0/tests/test_worker.py

@@ -0,0 +1,161 @@
+import os, signal, tempfile, time, unittest, json
+from pathlib import Path
+from unittest.mock import patch
+
+from trinity_lite.bus import TrinityBus
+from trinity_lite.worker import (
+    run_once, run_loop, _acquire_pid_file, _cleanup_pid_file,
+    _check_existing_pid, _read_pid_file, _stop_flag,
+    _install_signal_handlers, _default_pid_path,
+)
+
+
+class WorkerTest(unittest.TestCase):
+    def test_mock_worker_completes_task(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            bus = TrinityBus(root / "bus.db", allowed_roots=[root])
+            task = bus.submit_task("user", "codex", "implement hello", cwd=root)
+            done = run_once("codex", bus)
+            self.assertEqual(done["id"], task["id"])
+            self.assertEqual(done["status"], "completed")
+            self.assertIn("[mock:codex]", done["result"])
+
+    def test_missing_configured_agent_fails_task(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            bus = TrinityBus(root / "bus.db", allowed_roots=[root])
+            task = bus.submit_task("user", "unknown", "work", cwd=root)
+            done = run_once("unknown", bus)
+            self.assertEqual(done["id"], task["id"])
+            self.assertEqual(done["status"], "failed")
+            self.assertIn("agent not configured", done["error"])
+
+    def test_command_adapter_failure_is_recorded(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            agents_path = root / "agents.json"
+            agents_path.write_text(json.dumps({
+                "agents": {
+                    "codex": {
+                        "mode": "command",
+                        "command": ["definitely-not-a-real-trinity-lite-command"]
+                    }
+                }
+            }), encoding="utf-8")
+            bus = TrinityBus(root / "bus.db", allowed_roots=[root])
+            task = bus.submit_task("user", "codex", "work", cwd=root)
+            done = run_once("codex", bus, str(agents_path))
+            self.assertEqual(done["id"], task["id"])
+            self.assertEqual(done["status"], "failed")
+            self.assertIn("executable not found", done["error"])
+
+    def test_memory_error_is_not_swallowed(self):
+        class OomAdapter:
+            def run(self, task):
+                raise MemoryError("oom")
+
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            bus = TrinityBus(root / "bus.db", allowed_roots=[root])
+            task = bus.submit_task("user", "codex", "work", cwd=root)
+            with patch("trinity_lite.worker.build_adapter", return_value=OomAdapter()):
+                with self.assertRaises(MemoryError):
+                    run_once("codex", bus)
+            self.assertEqual(bus.get_task(task["id"])["status"], "running")
+
+    # ── New daemon tests ──
+
+    def test_run_loop_stop_flag(self):
+        """Start loop, set stop_flag, verify exits cleanly."""
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            bus = TrinityBus(root / "bus.db", allowed_roots=[root])
+            _stop_flag.clear()
+            # Set stop flag after a short delay in a separate thread
+            import threading
+            def set_stop():
+                time.sleep(0.15)
+                _stop_flag.set()
+            t = threading.Thread(target=set_stop)
+            t.start()
+            exit_code = run_loop("codex", bus, poll_seconds=0.05)
+            t.join()
+            self.assertEqual(exit_code, 0)
+
+    def test_pid_file_creation(self):
+        """Verify PID file created with correct contents."""
+        with tempfile.TemporaryDirectory() as tmp:
+            pid_path = Path(tmp) / "test.pid"
+            _acquire_pid_file(pid_path)
+            self.assertTrue(pid_path.exists())
+            pid = int(pid_path.read_text().strip())
+            self.assertEqual(pid, os.getpid())
+            _cleanup_pid_file(pid_path)
+
+    def test_pid_file_cleanup_on_exit(self):
+        """Verify PID file created during daemon loop and cleanup works."""
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            pid_path = Path(tmp) / "cleanup_test.pid"
+            bus = TrinityBus(root / "bus.db", allowed_roots=[root])
+            _stop_flag.clear()
+            import threading
+            def set_stop():
+                time.sleep(0.15)
+                _stop_flag.set()
+            t = threading.Thread(target=set_stop)
+            t.start()
+            exit_code = run_loop("codex", bus, poll_seconds=0.05, pid_file=pid_path)
+            t.join()
+            self.assertEqual(exit_code, 0)
+            # PID file was created
+            self.assertTrue(pid_path.exists())
+            # Manually verify cleanup works (atexit fires at process exit)
+            _cleanup_pid_file(pid_path)
+            self.assertFalse(pid_path.exists())
+
+    def test_duplicate_daemon_prevented(self):
+        """Verify second attempt to acquire PID raises error."""
+        with tempfile.TemporaryDirectory() as tmp:
+            pid_path = Path(tmp) / "dup.pid"
+            # Write our own PID first
+            _acquire_pid_file(pid_path)
+            self.assertTrue(pid_path.exists())
+            # Second attempt should raise
+            with self.assertRaises(RuntimeError):
+                _check_existing_pid(pid_path)
+            _cleanup_pid_file(pid_path)
+
+    def test_stale_pid_cleanup(self):
+        """Write fake PID, verify it's treated as stale and can be re-acquired."""
+        with tempfile.TemporaryDirectory() as tmp:
+            pid_path = Path(tmp) / "stale.pid"
+            # Write a PID that doesn't exist
+            pid_path.write_text("99999")
+            # Should be treated as stale (None returned)
+            result = _check_existing_pid(pid_path)
+            self.assertIsNone(result)
+
+    def test_read_pid_file(self):
+        """Test _read_pid_file returns correct PID."""
+        with tempfile.TemporaryDirectory() as tmp:
+            pid_path = Path(tmp) / "read.pid"
+            pid_path.write_text("42")
+            self.assertEqual(_read_pid_file(pid_path), 42)
+            # Corrupt file
+            pid_path.write_text("not_a_pid")
+            self.assertIsNone(_read_pid_file(pid_path))
+            # Missing file
+            self.assertIsNone(_read_pid_file(Path(tmp) / "nonexistent.pid"))
+
+    def test_default_pid_path(self):
+        """Test default PID path resolution."""
+        path = _default_pid_path("codex")
+        self.assertIn(".trinity", str(path))
+        self.assertIn("workers", str(path))
+        self.assertTrue(str(path).endswith("codex.pid"))
+
+
+if __name__ == "__main__":
+    unittest.main()

{trinity_lite-0.2.3 → trinity_lite-0.4.0}/trinity_lite/__init__.py

@@ -1,3 +1,3 @@
 """Trinity Lite: a minimal public multi-agent task bus."""
 
-__version__ = "0.2.2"
+__version__ = "0.4.0"

{trinity_lite-0.2.3 → trinity_lite-0.4.0}/trinity_lite/cli.py

@@ -12,8 +12,9 @@ from typing import Any
 from .bus import TrinityBus
 from .doctor import run_doctor
 from .orchestrator import run_review_flow
+from .pipeline import load_pipeline, run_pipeline
 from .router import resolve_route
-from .worker import run_loop, run_once
+from .worker import _default_pid_path, run_loop, run_once
 
 
 def print_json(data: Any) -> None:
@@ -24,11 +25,9 @@ def _version() -> str:
     """Return the installed version, favouring importlib.metadata."""
     try:
         from importlib.metadata import PackageNotFoundError, version  # Python >= 3.8
-
         return version("trinity-lite")
     except (ImportError, PackageNotFoundError):
         from . import __version__
-
         return __version__  # pragma: no cover — fallback for development
 
 
@@ -40,7 +39,8 @@ Quick demo:  trinity-lite demo
 Full help:   trinity-lite --help
 
 Commands: demo, dispatch, dispatch-auto, worker, orchestrate,
-          status, tasks, route, doctor, send, inbox, mcp"""
+          status, tasks, route, doctor, send, inbox, mcp,
+          setup-models, detect-models"""
 
 
 def build_parser() -> argparse.ArgumentParser:
@@ -77,6 +77,7 @@ def build_parser() -> argparse.ArgumentParser:
 
     orchestrate = sub.add_parser("orchestrate", parents=[common], help="dispatch and run a primary task with optional review")
     orchestrate.add_argument("task")
+    orchestrate.add_argument("--pipeline", default=None, help="path to pipeline YAML (uses pipeline orchestration instead of review flow)")
     orchestrate.add_argument("--source", default="user")
     orchestrate.add_argument("--type", dest="task_type")
     orchestrate.add_argument("--previous-agent")
@@ -94,8 +95,10 @@ def build_parser() -> argparse.ArgumentParser:
 
     worker = sub.add_parser("worker", parents=[common], help="run a worker for one agent")
     worker.add_argument("agent")
-    worker.add_argument("--once", action="store_true")
-    worker.add_argument("--poll", type=float, default=2.0)
+    worker.add_argument("--once", action="store_true", help="run a single worker cycle and exit")
+    worker.add_argument("--poll", type=float, default=2.0, help="poll interval in seconds (default: 2.0)")
+    worker.add_argument("--daemon", action="store_true", help="run in continuous daemon mode with signal handling and PID locking")
+    worker.add_argument("--pid-file", default=None, help="custom PID file path (default: ~/.trinity/workers/<agent>.pid)")
 
     send = sub.add_parser("send", parents=[common], help="send a durable message")
     send.add_argument("target_agent")
@@ -124,6 +127,14 @@ def build_parser() -> argparse.ArgumentParser:
 
     demo = sub.add_parser("demo", parents=[common], help="run a guided first-run demo")
 
+    # Model pool commands
+    setup_models = sub.add_parser("setup-models", parents=[common],
+                                   help="interactive model pool setup (no JSON knowledge needed)")
+    detect_models = sub.add_parser("detect-models", parents=[common],
+                                    help="auto-detect available LLM backends from your environment")
+    detect_models.add_argument("--no-save", action="store_true",
+                                help="print result without saving to disk")
+
     mcp = sub.add_parser("mcp", help="MCP server control")
     mcp_sub = mcp.add_subparsers(dest="mcp_command")
     mcp_sub.required = False
@@ -135,7 +146,6 @@ def build_parser() -> argparse.ArgumentParser:
 def main(argv: list[str] | None = None) -> int:
     parser = build_parser()
 
-    # No-args: show friendly intro
     if argv is None:
         argv = sys.argv[1:]
     if not argv:
@@ -144,12 +154,10 @@ def main(argv: list[str] | None = None) -> int:
 
     args = parser.parse_args(argv)
 
-    # --version flag (before subcommand)
     if args.version:
         print(f"trinity-lite {_version()}")
         return 0
 
-    # No subcommand but unknown args → show friendly intro
     if args.command is None:
         print(BANNER)
         return 0
@@ -198,17 +206,30 @@ def run_command(args: argparse.Namespace) -> int:
         print_json(task)
         return 0
     if args.command == "orchestrate":
-        result = run_review_flow(
-            args.task,
-            bus,
-            args.routes,
-            args.agents,
-            args.source,
-            args.task_type,
-            args.previous_agent,
-            args.cwd,
-            run_workers=not args.no_run and not getattr(args, "wait", False),
-        )
+        if args.pipeline:
+            pipeline = load_pipeline(args.pipeline)
+            result = run_pipeline(
+                pipeline,
+                args.task,
+                bus,
+                args.routes,
+                args.agents,
+                args.source,
+                cwd=args.cwd,
+                run_workers=not args.no_run and not getattr(args, "wait", False),
+            )
+        else:
+            result = run_review_flow(
+                args.task,
+                bus,
+                args.routes,
+                args.agents,
+                args.source,
+                args.task_type,
+                args.previous_agent,
+                args.cwd,
+                run_workers=not args.no_run and not getattr(args, "wait", False),
+            )
         if getattr(args, "wait", False):
             result = _wait_for_flow(bus, result, args.agents, args.routes, args.wait_timeout)
         print_json(result)
@@ -223,6 +244,9 @@ def run_command(args: argparse.Namespace) -> int:
         if args.once:
             print_json(run_once(args.agent, bus, args.agents))
             return 0
+        if args.daemon:
+            pid_file = args.pid_file or str(_default_pid_path(args.agent))
+            return run_loop(args.agent, bus, args.agents, args.poll, pid_file=pid_file)
         run_loop(args.agent, bus, args.agents, args.poll)
         return 0
     if args.command == "send":
@@ -246,9 +270,23 @@ def run_command(args: argparse.Namespace) -> int:
     if args.command == "mcp":
         return _mcp(args, bus)
 
-    raise AssertionError(f"unhandled command: {args.command}")
-
+    # Model pool commands (no bus needed)
+    if args.command == "setup-models":
+        from .model_pool_wizard import main as wizard_main
+        wizard_main()
+        return 0
+    if args.command == "detect-models":
+        from .model_autodetect import scan, save_pool
+        pool = scan()
+        print(f"Detected {len(pool)} backend(s):")
+        for name, info in pool.items():
+            print(f"  • {name} ({info['tier']}) — {', '.join(info['strengths'][:3])}")
+        if not getattr(args, "no_save", False):
+            path = save_pool(pool)
+            print(f"Saved to {path}")
+        return 0
 
+    raise AssertionError(f"unhandled command: {args.command}")
 def _wait_for_task(
     bus: TrinityBus,
     task_id: str,