trinity-lite 0.2.2__tar.gz → 0.3.1__tar.gz

trinity_lite-0.3.1/PKG-INFO

@@ -0,0 +1,167 @@
+Metadata-Version: 2.4
+Name: trinity-lite
+Version: 0.3.1
+Summary: The bus that lets your AI agents talk to each other.
+Author: Yomiracle
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Yomiracle/trinity-lite
+Project-URL: Repository, https://github.com/Yomiracle/trinity-lite
+Project-URL: Issues, https://github.com/Yomiracle/trinity-lite/issues
+Keywords: ai-agent,multi-agent,agent-orchestration,codex,claude-code
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: mcp
+Requires-Dist: mcp>=1.0; extra == "mcp"
+Provides-Extra: agent-skill
+Requires-Dist: agent-skill-system>=1.0.6; extra == "agent-skill"
+Dynamic: license-file
+
+# Trinity Lite
+
+[![Tests](https://github.com/Yomiracle/trinity-lite/actions/workflows/test.yml/badge.svg)](https://github.com/Yomiracle/trinity-lite/actions/workflows/test.yml)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-blue.svg)](pyproject.toml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+[![PyPI](https://img.shields.io/pypi/v/trinity-lite.svg)](https://pypi.org/project/trinity-lite/)
+
+**The bus that lets your AI agents talk to each other.**
+
+[中文 README](README_zh.md)
+
+## The problem
+
+You already use Claude Code. Maybe you just installed Codex. You want them to collaborate — but there's no built-in way to route tasks between them, remember who did what, or stop them from stepping on each other. Trinity Lite is the missing layer.
+
+## What it does
+
+- **Route by capability, not name.** You describe the task. The router matches it to the right agent — no hardcoded agent names, no fragile dispatch logic. *"Implement a rate limiter" lands on the agent you tagged `implement`. "Review the auth module" goes to the agent tagged `review`.*
+- **Give every agent a pull queue.** Workers read pending tasks from the shared bus, execute them via CLI, and write results back. Each agent polls on its own schedule. You never copy-paste an output between terminals again.
+- **Remember every decision.** Every task, status change, result, error, and inter-agent message lands in a local SQLite database. Query who did what, when, and what happened — without setting up a logging pipeline.
+- **Block footguns before they fire.** Self-delegation loops are rejected. Delegation depth has a hard cap. Working directories must be in the allowlist. You ship features, not incident reports.
+
+## Quick start
+
+30 seconds, no agents required:
+
+```bash
+pip install trinity-lite
+trinity-lite doctor
+trinity-lite dispatch-auto "implement a hello-world function"
+trinity-lite worker codex --once
+trinity-lite tasks
+```
+
+Mock agents are built in. You see the full dispatch → execute → result cycle before you wire up anything real.
+
+## Not another framework
+
+Trinity Lite doesn't build agents. It connects the agents you already have.
+
+LangGraph and CrewAI give you primitives for building agents from scratch — graph definitions, role abstractions, tool wrappers. Trinity Lite starts from the opposite end: Claude Code is running in one terminal, Codex is running in another, and they need a shared task bus, durable state, and safety boundaries. No SDK to learn. No new agent abstraction. Just a bus that works with the CLIs you already use.
+
+## Who this is for
+
+| You are... | Trinity Lite helps you... |
+|------------|---------------------------|
+| Copy-pasting prompts and outputs between two agent terminals all day | Dispatch once to the bus and let agents pull their own work |
+| Prototyping a multi-agent pipeline before committing infrastructure | Run the full flow with mock agents — no API keys, no provisioning |
+| Running everything on a single machine with zero server setup | Keep your state in SQLite, your runtime in stdlib, your daemon count at zero |
+| Showing a colleague how multi-agent collaboration works | `pip install` → five commands → they see it run. No explanation needed. |
+
+## Features
+
+- **Route by capability.** Tag agents with `implement`, `review`, `audit` — the router matches tasks to the agent that can do them. No agent names in your dispatch logic.
+- **Dispatch directly when you need control.** Bypass the router and send a task straight to `claude_code` or `codex`. Best of both worlds.
+- **Persist everything in SQLite.** Tasks, statuses, results, errors, and messages in one local file. Query it with `sqlite3` or any tool that speaks SQL.
+- **Run CLI workers on demand.** `trinity-lite worker codex --once` pulls one queued task, executes the agent's command, and writes the result. Run it in a loop, in cron, or by hand.
+- **Execute safely, no shell injection.** Agent commands are JSON arrays run with `shell=False`. No string interpolation into a shell. No surprises.
+- **Test with mock agents.** Mock agents simulate the full cycle without real CLIs. Prototype routing, persistence, and review handoffs first. Wire up real agents later.
+- **Guard against runaway delegation.** Self-delegation is blocked. Delegation depth is capped. Working directories are allowlisted. Safe by default.
+- **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.
+
+## Install
+
+```bash
+pip install trinity-lite
+```
+
+Python 3.10+. Zero runtime dependencies. Standard library only.
+
+### Optional extras
+
+```bash
+pip install trinity-lite[mcp]           # MCP server — 10 tools + 3 resources
+pip install trinity-lite[agent-skill]   # agent-skill-system integration
+```
+
+## Workflow example
+
+Hermes routes → Codex implements → Claude Code reviews. Five commands, one audit trail.
+
+```bash
+# Hermes sends the task. The router picks Codex automatically.
+trinity-lite dispatch-auto "implement a rate limiter for the API" --source-agent hermes
+
+# Codex pulls the task and runs it.
+trinity-lite worker codex --once --agents agents.local.json
+
+# Claude Code reviews the result.
+trinity-lite send claude_code "please review task <task_id>" --source-agent hermes
+trinity-lite worker claude_code --once --agents agents.local.json
+
+# Read the full trail.
+trinity-lite status <task_id>
+```
+
+Works immediately with mock agents. Ready for real CLIs when you are:
+
+```bash
+cp examples/agents.command.example.json agents.local.json
+```
+
+## MCP server
+
+Turn the task bus into an MCP server. Let any MCP client dispatch, query, and route tasks.
+
+```bash
+pip install trinity-lite[mcp]
+trinity-lite mcp serve
+```
+
+**10 tools:**
+
+| Tool | What it does |
+|------|--------------|
+| `trinity_dispatch` | Dispatch a task to a specific agent |
+| `trinity_dispatch_auto` | Dispatch and let the capability router pick the agent |
+| `trinity_status` | Get the state and result of any task by ID |
+| `trinity_tasks` | List recent tasks, filterable by agent |
+| `trinity_worker` | Run one worker cycle for an agent |
+| `trinity_doctor` | Run health and diagnostic checks |
+| `trinity_inbox` | Read durable messages for an agent |
+| `trinity_send` | Send a message from one agent to another |
+| `trinity_skill_search` | Search agent-skill-system for relevant skills |
+| `trinity_skill_load` | Load the full content of a named skill |
+
+**3 resources:** `trinity://health`, `trinity://tasks/recent`, `trinity://tasks/{task_id}`
+
+## Links
+
+- [PyPI](https://pypi.org/project/trinity-lite/)
+- [Documentation](docs/)
+- [Changelog](CHANGELOG.md)
+- [Contributing](CONTRIBUTING.md)
+- [Architecture](docs/ARCHITECTURE.md)
+- [Real agent setup](docs/REAL_AGENTS.md)
+
+## License
+
+MIT

trinity_lite-0.3.1/README.md

@@ -0,0 +1,142 @@
+# Trinity Lite
+
+[![Tests](https://github.com/Yomiracle/trinity-lite/actions/workflows/test.yml/badge.svg)](https://github.com/Yomiracle/trinity-lite/actions/workflows/test.yml)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-blue.svg)](pyproject.toml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+[![PyPI](https://img.shields.io/pypi/v/trinity-lite.svg)](https://pypi.org/project/trinity-lite/)
+
+**The bus that lets your AI agents talk to each other.**
+
+[中文 README](README_zh.md)
+
+## The problem
+
+You already use Claude Code. Maybe you just installed Codex. You want them to collaborate — but there's no built-in way to route tasks between them, remember who did what, or stop them from stepping on each other. Trinity Lite is the missing layer.
+
+## What it does
+
+- **Route by capability, not name.** You describe the task. The router matches it to the right agent — no hardcoded agent names, no fragile dispatch logic. *"Implement a rate limiter" lands on the agent you tagged `implement`. "Review the auth module" goes to the agent tagged `review`.*
+- **Give every agent a pull queue.** Workers read pending tasks from the shared bus, execute them via CLI, and write results back. Each agent polls on its own schedule. You never copy-paste an output between terminals again.
+- **Remember every decision.** Every task, status change, result, error, and inter-agent message lands in a local SQLite database. Query who did what, when, and what happened — without setting up a logging pipeline.
+- **Block footguns before they fire.** Self-delegation loops are rejected. Delegation depth has a hard cap. Working directories must be in the allowlist. You ship features, not incident reports.
+
+## Quick start
+
+30 seconds, no agents required:
+
+```bash
+pip install trinity-lite
+trinity-lite doctor
+trinity-lite dispatch-auto "implement a hello-world function"
+trinity-lite worker codex --once
+trinity-lite tasks
+```
+
+Mock agents are built in. You see the full dispatch → execute → result cycle before you wire up anything real.
+
+## Not another framework
+
+Trinity Lite doesn't build agents. It connects the agents you already have.
+
+LangGraph and CrewAI give you primitives for building agents from scratch — graph definitions, role abstractions, tool wrappers. Trinity Lite starts from the opposite end: Claude Code is running in one terminal, Codex is running in another, and they need a shared task bus, durable state, and safety boundaries. No SDK to learn. No new agent abstraction. Just a bus that works with the CLIs you already use.
+
+## Who this is for
+
+| You are... | Trinity Lite helps you... |
+|------------|---------------------------|
+| Copy-pasting prompts and outputs between two agent terminals all day | Dispatch once to the bus and let agents pull their own work |
+| Prototyping a multi-agent pipeline before committing infrastructure | Run the full flow with mock agents — no API keys, no provisioning |
+| Running everything on a single machine with zero server setup | Keep your state in SQLite, your runtime in stdlib, your daemon count at zero |
+| Showing a colleague how multi-agent collaboration works | `pip install` → five commands → they see it run. No explanation needed. |
+
+## Features
+
+- **Route by capability.** Tag agents with `implement`, `review`, `audit` — the router matches tasks to the agent that can do them. No agent names in your dispatch logic.
+- **Dispatch directly when you need control.** Bypass the router and send a task straight to `claude_code` or `codex`. Best of both worlds.
+- **Persist everything in SQLite.** Tasks, statuses, results, errors, and messages in one local file. Query it with `sqlite3` or any tool that speaks SQL.
+- **Run CLI workers on demand.** `trinity-lite worker codex --once` pulls one queued task, executes the agent's command, and writes the result. Run it in a loop, in cron, or by hand.
+- **Execute safely, no shell injection.** Agent commands are JSON arrays run with `shell=False`. No string interpolation into a shell. No surprises.
+- **Test with mock agents.** Mock agents simulate the full cycle without real CLIs. Prototype routing, persistence, and review handoffs first. Wire up real agents later.
+- **Guard against runaway delegation.** Self-delegation is blocked. Delegation depth is capped. Working directories are allowlisted. Safe by default.
+- **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.
+
+## Install
+
+```bash
+pip install trinity-lite
+```
+
+Python 3.10+. Zero runtime dependencies. Standard library only.
+
+### Optional extras
+
+```bash
+pip install trinity-lite[mcp]           # MCP server — 10 tools + 3 resources
+pip install trinity-lite[agent-skill]   # agent-skill-system integration
+```
+
+## Workflow example
+
+Hermes routes → Codex implements → Claude Code reviews. Five commands, one audit trail.
+
+```bash
+# Hermes sends the task. The router picks Codex automatically.
+trinity-lite dispatch-auto "implement a rate limiter for the API" --source-agent hermes
+
+# Codex pulls the task and runs it.
+trinity-lite worker codex --once --agents agents.local.json
+
+# Claude Code reviews the result.
+trinity-lite send claude_code "please review task <task_id>" --source-agent hermes
+trinity-lite worker claude_code --once --agents agents.local.json
+
+# Read the full trail.
+trinity-lite status <task_id>
+```
+
+Works immediately with mock agents. Ready for real CLIs when you are:
+
+```bash
+cp examples/agents.command.example.json agents.local.json
+```
+
+## MCP server
+
+Turn the task bus into an MCP server. Let any MCP client dispatch, query, and route tasks.
+
+```bash
+pip install trinity-lite[mcp]
+trinity-lite mcp serve
+```
+
+**10 tools:**
+
+| Tool | What it does |
+|------|--------------|
+| `trinity_dispatch` | Dispatch a task to a specific agent |
+| `trinity_dispatch_auto` | Dispatch and let the capability router pick the agent |
+| `trinity_status` | Get the state and result of any task by ID |
+| `trinity_tasks` | List recent tasks, filterable by agent |
+| `trinity_worker` | Run one worker cycle for an agent |
+| `trinity_doctor` | Run health and diagnostic checks |
+| `trinity_inbox` | Read durable messages for an agent |
+| `trinity_send` | Send a message from one agent to another |
+| `trinity_skill_search` | Search agent-skill-system for relevant skills |
+| `trinity_skill_load` | Load the full content of a named skill |
+
+**3 resources:** `trinity://health`, `trinity://tasks/recent`, `trinity://tasks/{task_id}`
+
+## Links
+
+- [PyPI](https://pypi.org/project/trinity-lite/)
+- [Documentation](docs/)
+- [Changelog](CHANGELOG.md)
+- [Contributing](CONTRIBUTING.md)
+- [Architecture](docs/ARCHITECTURE.md)
+- [Real agent setup](docs/REAL_AGENTS.md)
+
+## License
+
+MIT

{trinity_lite-0.2.2 → trinity_lite-0.3.1}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "trinity-lite"
-version = "0.2.2"
-description = "A minimal public multi-agent task bus with routing, workers, and safety checks."
+version = "0.3.1"
+description = "The bus that lets your AI agents talk to each other."
 readme = "README.md"
 requires-python = ">=3.10"
 license = "MIT"

{trinity_lite-0.2.2 → trinity_lite-0.3.1}/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.3.1/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()