htmlgraph 0.20.2__tar.gz → 0.20.3__tar.gz

{htmlgraph-0.20.2 → htmlgraph-0.20.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: htmlgraph
-Version: 0.20.2
+Version: 0.20.3
 Summary: HTML is All You Need - Graph database on web standards
 Project-URL: Homepage, https://github.com/Shakes-tzd/htmlgraph
 Project-URL: Documentation, https://github.com/Shakes-tzd/htmlgraph#readme

{htmlgraph-0.20.2 → htmlgraph-0.20.3}/packages/gemini-extension/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "htmlgraph",
-  "version": "0.20.2",
+  "version": "0.20.3",
   "description": "HtmlGraph session tracking and documentation for Gemini CLI. Ensures proper activity attribution, feature awareness, and continuous work tracking.",
   "author": "Shakes",
   "license": "MIT",

{htmlgraph-0.20.2 → htmlgraph-0.20.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "htmlgraph"
-version = "0.20.2"
+version = "0.20.3"
 description = "HTML is All You Need - Graph database on web standards"
 authors = [{name = "Shakes", email = "shakestzd@gmail.com"}]
 readme = "README.md"

{htmlgraph-0.20.2 → htmlgraph-0.20.3}/src/python/htmlgraph/__init__.py

@@ -84,7 +84,7 @@ from htmlgraph.types import (
 )
 from htmlgraph.work_type_utils import infer_work_type, infer_work_type_from_id
 
-__version__ = "0.20.2"
+__version__ = "0.20.3"
 __all__ = [
     # Exceptions
     "HtmlGraphError",

{htmlgraph-0.20.2 → htmlgraph-0.20.3}/src/python/htmlgraph/cli.py

@@ -2724,12 +2724,53 @@ def cmd_orchestrator_status(args: argparse.Namespace) -> None:
             print(f"Activated at: {status['activated_at']}")
         if status["auto_activated"]:
             print("Auto-activated: yes")
+
+        # Show violation tracking info
+        violations = status.get("violations", 0)
+        circuit_breaker = status.get("circuit_breaker_triggered", False)
+        if violations > 0:
+            print(f"Violations: {violations}/3")
+            if circuit_breaker:
+                print("⚠️  Circuit breaker: TRIGGERED")
     else:
         print("Orchestrator mode: disabled")
         if status["disabled_by_user"]:
             print("Disabled by user (auto-activation prevented)")
 
 
+def cmd_orchestrator_set_level(args: argparse.Namespace) -> None:
+    """Set orchestrator mode enforcement level."""
+    from typing import Literal
+
+    from htmlgraph.orchestrator_mode import OrchestratorModeManager
+
+    manager = OrchestratorModeManager(args.graph_dir)
+    level: Literal["strict", "guidance"] = args.level
+    manager.set_level(level)
+
+    level_text = "strict enforcement" if level == "strict" else "guidance mode"
+    print(f"✓ Orchestrator enforcement level set to: {level_text}")
+
+
+def cmd_orchestrator_reset_violations(args: argparse.Namespace) -> None:
+    """Reset orchestrator mode violation counter."""
+    from htmlgraph.orchestrator_mode import OrchestratorModeManager
+
+    manager = OrchestratorModeManager(args.graph_dir)
+
+    # Check if mode is enabled
+    if not manager.is_enabled():
+        print("⚠️  Orchestrator mode is not enabled")
+        return
+
+    # Reset violations
+    manager.reset_violations()
+
+    print("✓ Violation counter reset")
+    print("Circuit breaker: cleared")
+    print("You can now continue with delegation workflow")
+
+
 def cmd_publish(args: argparse.Namespace) -> None:
     """Build and publish the package to PyPI (Interoperable)."""
     import shutil
@@ -4475,6 +4516,27 @@ For more help: https://github.com/Shakes-tzd/htmlgraph
         "--graph-dir", "-g", default=".htmlgraph", help="Graph directory"
     )
 
+    # orchestrator set-level
+    orchestrator_set_level = orchestrator_subparsers.add_parser(
+        "set-level", help="Set enforcement level"
+    )
+    orchestrator_set_level.add_argument(
+        "level",
+        choices=["strict", "guidance"],
+        help="Enforcement level to set",
+    )
+    orchestrator_set_level.add_argument(
+        "--graph-dir", "-g", default=".htmlgraph", help="Graph directory"
+    )
+
+    # orchestrator reset-violations
+    orchestrator_reset_violations = orchestrator_subparsers.add_parser(
+        "reset-violations", help="Reset violation counter and circuit breaker"
+    )
+    orchestrator_reset_violations.add_argument(
+        "--graph-dir", "-g", default=".htmlgraph", help="Graph directory"
+    )
+
     # install-gemini-extension
     subparsers.add_parser(
         "install-gemini-extension",
@@ -4678,6 +4740,10 @@ For more help: https://github.com/Shakes-tzd/htmlgraph
             cmd_orchestrator_disable(args)
         elif args.orchestrator_command == "status":
             cmd_orchestrator_status(args)
+        elif args.orchestrator_command == "set-level":
+            cmd_orchestrator_set_level(args)
+        elif args.orchestrator_command == "reset-violations":
+            cmd_orchestrator_reset_violations(args)
         else:
             orchestrator_parser.print_help()
             sys.exit(1)

{htmlgraph-0.20.2 → htmlgraph-0.20.3}/src/python/htmlgraph/hooks/orchestrator.py

@@ -358,6 +358,31 @@ def enforce_orchestrator_mode(tool: str, params: dict) -> dict:
             },
         }
 
+    # Check if circuit breaker is triggered in strict mode
+    if enforcement_level == "strict" and manager.is_circuit_breaker_triggered():
+        # Circuit breaker triggered - block all non-core operations
+        if tool not in ["Task", "AskUserQuestion", "TodoWrite"]:
+            circuit_breaker_message = (
+                "🚨 ORCHESTRATOR CIRCUIT BREAKER TRIGGERED\n\n"
+                f"You have violated delegation rules {manager.get_violation_count()} times this session.\n\n"
+                "Violations detected:\n"
+                "- Direct execution instead of delegation\n"
+                "- Context waste on tactical operations\n\n"
+                "Options:\n"
+                "1. Disable orchestrator mode: uv run htmlgraph orchestrator disable\n"
+                "2. Change to guidance mode: uv run htmlgraph orchestrator set-level guidance\n"
+                "3. Reset counter (acknowledge violations): uv run htmlgraph orchestrator reset-violations\n\n"
+                "To proceed, choose an option above."
+            )
+
+            return {
+                "hookSpecificOutput": {
+                    "hookEventName": "PreToolUse",
+                    "permissionDecision": "deny",
+                    "permissionDecisionReason": circuit_breaker_message,
+                },
+            }
+
     # Check if operation is allowed
     is_allowed, reason, category = is_allowed_orchestrator_operation(tool, params)
 
@@ -386,19 +411,35 @@ def enforce_orchestrator_mode(tool: str, params: dict) -> dict:
             },
         }
 
-    # Operation not allowed - provide strong warnings
-    # NOTE: {"continue": False} doesn't work in Claude Code, so we use advisory warnings only
+    # Operation not allowed - track violation and provide warnings
+    if enforcement_level == "strict":
+        # Increment violation counter
+        mode = manager.increment_violation()
+        violations = mode.violations
+
     suggestion = create_task_suggestion(tool, params)
 
     if enforcement_level == "strict":
-        # STRICT mode - loud warning but allow (blocking doesn't work)
+        # STRICT mode - loud warning with violation count
         error_message = (
-            f"🚫 ORCHESTRATOR MODE VIOLATION: {reason}\n\n"
+            f"🚫 ORCHESTRATOR MODE VIOLATION ({violations}/3): {reason}\n\n"
             f"⚠️  WARNING: Direct operations waste context and break delegation pattern!\n\n"
             f"Suggested delegation:\n"
             f"{suggestion}\n\n"
-            f"See ORCHESTRATOR_DIRECTIVES in session context for HtmlGraph delegation pattern.\n"
-            f"To disable orchestrator mode: uv run htmlgraph orchestrator disable"
+        )
+
+        # Add circuit breaker warning if approaching threshold
+        if violations >= 3:
+            error_message += (
+                "🚨 CIRCUIT BREAKER TRIGGERED - Further violations will be blocked!\n\n"
+                "Reset with: uv run htmlgraph orchestrator reset-violations\n"
+            )
+        elif violations == 2:
+            error_message += "⚠️  Next violation will trigger circuit breaker!\n\n"
+
+        error_message += (
+            "See ORCHESTRATOR_DIRECTIVES in session context for HtmlGraph delegation pattern.\n"
+            "To disable orchestrator mode: uv run htmlgraph orchestrator disable"
         )
 
         return {

{htmlgraph-0.20.2 → htmlgraph-0.20.3}/src/python/htmlgraph/orchestrator_mode.py

@@ -34,6 +34,15 @@ class OrchestratorMode(BaseModel):
     disabled_by_user: bool = False
     """Whether user explicitly disabled mode (prevents auto-reactivation)."""
 
+    violations: int = 0
+    """Count of delegation violations in current session."""
+
+    last_violation_at: datetime | None = None
+    """Timestamp of most recent violation."""
+
+    circuit_breaker_triggered: bool = False
+    """Whether circuit breaker has been triggered (3+ violations)."""
+
     def to_dict(self) -> dict:
         """Convert to dict for JSON serialization."""
         return {
@@ -45,6 +54,11 @@ class OrchestratorMode(BaseModel):
             "enforcement_level": self.enforcement_level,
             "auto_activated": self.auto_activated,
             "disabled_by_user": self.disabled_by_user,
+            "violations": self.violations,
+            "last_violation_at": (
+                self.last_violation_at.isoformat() if self.last_violation_at else None
+            ),
+            "circuit_breaker_triggered": self.circuit_breaker_triggered,
         }
 
     @classmethod
@@ -57,6 +71,13 @@ class OrchestratorMode(BaseModel):
                 activated_at = activated_at[:-1] + "+00:00"
             activated_at = datetime.fromisoformat(activated_at)
 
+        last_violation_at = data.get("last_violation_at")
+        if last_violation_at:
+            # Handle both 'Z' suffix and '+00:00' timezone format
+            if last_violation_at.endswith("Z"):
+                last_violation_at = last_violation_at[:-1] + "+00:00"
+            last_violation_at = datetime.fromisoformat(last_violation_at)
+
         return cls(
             enabled=data.get("enabled", False),
             activated_at=activated_at,
@@ -64,6 +85,9 @@ class OrchestratorMode(BaseModel):
             enforcement_level=data.get("enforcement_level", "strict"),
             auto_activated=data.get("auto_activated", False),
             disabled_by_user=data.get("disabled_by_user", False),
+            violations=data.get("violations", 0),
+            last_violation_at=last_violation_at,
+            circuit_breaker_triggered=data.get("circuit_breaker_triggered", False),
         )
 
 
@@ -214,4 +238,58 @@ class OrchestratorModeManager:
             ),
             "auto_activated": mode.auto_activated,
             "disabled_by_user": mode.disabled_by_user,
+            "violations": mode.violations,
+            "circuit_breaker_triggered": mode.circuit_breaker_triggered,
         }
+
+    def increment_violation(self) -> OrchestratorMode:
+        """
+        Increment violation counter and update timestamp.
+
+        Returns:
+            Updated OrchestratorMode with incremented violations
+        """
+        mode = self.load()
+        mode.violations += 1
+        mode.last_violation_at = datetime.now(timezone.utc)
+
+        # Trigger circuit breaker if threshold reached
+        if mode.violations >= 3:
+            mode.circuit_breaker_triggered = True
+
+        self.save(mode)
+        return mode
+
+    def reset_violations(self) -> OrchestratorMode:
+        """
+        Reset violation counter and circuit breaker.
+
+        Returns:
+            Updated OrchestratorMode with reset violations
+        """
+        mode = self.load()
+        mode.violations = 0
+        mode.last_violation_at = None
+        mode.circuit_breaker_triggered = False
+        self.save(mode)
+        return mode
+
+    def is_circuit_breaker_triggered(self) -> bool:
+        """
+        Check if circuit breaker is currently triggered.
+
+        Returns:
+            True if circuit breaker is active
+        """
+        mode = self.load()
+        return mode.circuit_breaker_triggered
+
+    def get_violation_count(self) -> int:
+        """
+        Get current violation count.
+
+        Returns:
+            Number of violations in current session
+        """
+        mode = self.load()
+        return mode.violations

htmlgraph-0.20.3/tests/python/test_orchestrator_circuit_breaker.py

@@ -0,0 +1,322 @@
+"""Tests for orchestrator circuit breaker pattern."""
+
+from htmlgraph.hooks.orchestrator import enforce_orchestrator_mode
+from htmlgraph.orchestrator_mode import OrchestratorModeManager
+
+
+class TestCircuitBreaker:
+    """Test circuit breaker enforcement."""
+
+    def test_violation_tracking_increments(self, tmp_path, monkeypatch):
+        """Test that violations are tracked correctly."""
+        # Change to tmp_path so enforce_orchestrator_mode finds .htmlgraph
+        monkeypatch.chdir(tmp_path)
+
+        manager = OrchestratorModeManager(tmp_path / ".htmlgraph")
+        manager.enable(level="strict")
+
+        # Simulate blocked operation
+        result = enforce_orchestrator_mode("Edit", {"file_path": "test.py"})
+
+        # Check violation was recorded
+        assert manager.get_violation_count() == 1
+        assert not manager.is_circuit_breaker_triggered()
+
+        # Verify warning message includes violation count
+        assert (
+            "VIOLATION (1/3)"
+            in result["hookSpecificOutput"]["permissionDecisionReason"]
+        )
+
+    def test_circuit_breaker_triggers_at_threshold(self, tmp_path, monkeypatch):
+        """Test circuit breaker triggers at 3 violations."""
+        monkeypatch.chdir(tmp_path)
+
+        manager = OrchestratorModeManager(tmp_path / ".htmlgraph")
+        manager.enable(level="strict")
+
+        # Trigger 3 violations
+        for i in range(3):
+            enforce_orchestrator_mode("Edit", {"file_path": f"test{i}.py"})
+
+        # Circuit breaker should be triggered
+        assert manager.get_violation_count() == 3
+        assert manager.is_circuit_breaker_triggered()
+
+    def test_circuit_breaker_blocks_subsequent_operations(self, tmp_path, monkeypatch):
+        """Test that circuit breaker blocks operations after trigger."""
+        monkeypatch.chdir(tmp_path)
+
+        manager = OrchestratorModeManager(tmp_path / ".htmlgraph")
+        manager.enable(level="strict")
+
+        # Trigger 3 violations
+        for i in range(3):
+            enforce_orchestrator_mode("Edit", {"file_path": f"test{i}.py"})
+
+        # Next operation should be blocked by circuit breaker
+        result = enforce_orchestrator_mode("Read", {"file_path": "test.py"})
+
+        assert result["hookSpecificOutput"]["permissionDecision"] == "deny"
+        assert (
+            "CIRCUIT BREAKER TRIGGERED"
+            in result["hookSpecificOutput"]["permissionDecisionReason"]
+        )
+
+    def test_circuit_breaker_allows_core_operations(self, tmp_path, monkeypatch):
+        """Test that circuit breaker allows Task/AskUserQuestion/TodoWrite."""
+        monkeypatch.chdir(tmp_path)
+
+        manager = OrchestratorModeManager(tmp_path / ".htmlgraph")
+        manager.enable(level="strict")
+
+        # Trigger circuit breaker
+        for i in range(3):
+            enforce_orchestrator_mode("Edit", {"file_path": f"test{i}.py"})
+
+        # Core operations should still be allowed
+        core_ops = [
+            ("Task", {"prompt": "test", "subagent_type": "general-purpose"}),
+            ("AskUserQuestion", {"question": "test"}),
+            ("TodoWrite", {"todos": []}),
+        ]
+
+        for tool, params in core_ops:
+            result = enforce_orchestrator_mode(tool, params)
+            assert result["hookSpecificOutput"]["permissionDecision"] == "allow"
+
+    def test_reset_violations_clears_counter(self, tmp_path, monkeypatch):
+        """Test that reset_violations clears counter and circuit breaker."""
+        monkeypatch.chdir(tmp_path)
+
+        manager = OrchestratorModeManager(tmp_path / ".htmlgraph")
+        manager.enable(level="strict")
+
+        # Trigger violations
+        for i in range(3):
+            enforce_orchestrator_mode("Edit", {"file_path": f"test{i}.py"})
+
+        assert manager.get_violation_count() == 3
+        assert manager.is_circuit_breaker_triggered()
+
+        # Reset
+        manager.reset_violations()
+
+        assert manager.get_violation_count() == 0
+        assert not manager.is_circuit_breaker_triggered()
+
+    def test_violation_warning_at_two(self, tmp_path, monkeypatch):
+        """Test special warning at 2 violations."""
+        monkeypatch.chdir(tmp_path)
+
+        manager = OrchestratorModeManager(tmp_path / ".htmlgraph")
+        manager.enable(level="strict")
+
+        # First violation
+        enforce_orchestrator_mode("Edit", {"file_path": "test1.py"})
+
+        # Second violation should warn about next one
+        result = enforce_orchestrator_mode("Edit", {"file_path": "test2.py"})
+
+        assert (
+            "VIOLATION (2/3)"
+            in result["hookSpecificOutput"]["permissionDecisionReason"]
+        )
+        assert (
+            "Next violation will trigger circuit breaker"
+            in result["hookSpecificOutput"]["permissionDecisionReason"]
+        )
+
+    def test_violation_message_at_threshold(self, tmp_path, monkeypatch):
+        """Test message when circuit breaker triggers."""
+        monkeypatch.chdir(tmp_path)
+
+        manager = OrchestratorModeManager(tmp_path / ".htmlgraph")
+        manager.enable(level="strict")
+
+        # First two violations
+        enforce_orchestrator_mode("Edit", {"file_path": "test1.py"})
+        enforce_orchestrator_mode("Edit", {"file_path": "test2.py"})
+
+        # Third violation triggers circuit breaker
+        result = enforce_orchestrator_mode("Edit", {"file_path": "test3.py"})
+
+        assert (
+            "VIOLATION (3/3)"
+            in result["hookSpecificOutput"]["permissionDecisionReason"]
+        )
+        assert (
+            "CIRCUIT BREAKER TRIGGERED"
+            in result["hookSpecificOutput"]["permissionDecisionReason"]
+        )
+        assert (
+            "reset-violations"
+            in result["hookSpecificOutput"]["permissionDecisionReason"]
+        )
+
+    def test_guidance_mode_does_not_track_violations(self, tmp_path, monkeypatch):
+        """Test that guidance mode doesn't track violations."""
+        monkeypatch.chdir(tmp_path)
+
+        manager = OrchestratorModeManager(tmp_path / ".htmlgraph")
+        manager.enable(level="guidance")
+
+        # Simulate multiple blocked operations
+        for i in range(5):
+            enforce_orchestrator_mode("Edit", {"file_path": f"test{i}.py"})
+
+        # No violations should be tracked in guidance mode
+        assert manager.get_violation_count() == 0
+        assert not manager.is_circuit_breaker_triggered()
+
+    def test_allowed_operations_dont_increment_violations(self, tmp_path, monkeypatch):
+        """Test that allowed operations don't increment violation counter."""
+        monkeypatch.chdir(tmp_path)
+
+        manager = OrchestratorModeManager(tmp_path / ".htmlgraph")
+        manager.enable(level="strict")
+
+        # Allowed operations
+        enforce_orchestrator_mode(
+            "Task", {"prompt": "test", "subagent_type": "general-purpose"}
+        )
+        enforce_orchestrator_mode(
+            "Read", {"file_path": "test.py"}
+        )  # First read is allowed
+        enforce_orchestrator_mode("Bash", {"command": "uv run htmlgraph status"})
+
+        # No violations should be recorded
+        assert manager.get_violation_count() == 0
+
+    def test_circuit_breaker_message_shows_options(self, tmp_path, monkeypatch):
+        """Test that circuit breaker message shows all options."""
+        monkeypatch.chdir(tmp_path)
+
+        manager = OrchestratorModeManager(tmp_path / ".htmlgraph")
+        manager.enable(level="strict")
+
+        # Trigger circuit breaker
+        for i in range(3):
+            enforce_orchestrator_mode("Edit", {"file_path": f"test{i}.py"})
+
+        # Check subsequent operation shows options
+        result = enforce_orchestrator_mode("Read", {"file_path": "test.py"})
+        message = result["hookSpecificOutput"]["permissionDecisionReason"]
+
+        assert "disable" in message.lower()
+        assert "set-level guidance" in message.lower()
+        assert "reset-violations" in message.lower()
+
+    def test_status_shows_violation_count(self, tmp_path, monkeypatch):
+        """Test that status command shows violation tracking."""
+        monkeypatch.chdir(tmp_path)
+
+        manager = OrchestratorModeManager(tmp_path / ".htmlgraph")
+        manager.enable(level="strict")
+
+        # Add some violations
+        enforce_orchestrator_mode("Edit", {"file_path": "test1.py"})
+        enforce_orchestrator_mode("Edit", {"file_path": "test2.py"})
+
+        status = manager.status()
+
+        assert status["violations"] == 2
+        assert status["circuit_breaker_triggered"] is False
+
+    def test_enable_resets_violations(self, tmp_path, monkeypatch):
+        """Test that enabling orchestrator mode resets violations."""
+        monkeypatch.chdir(tmp_path)
+
+        manager = OrchestratorModeManager(tmp_path / ".htmlgraph")
+        manager.enable(level="strict")
+
+        # Trigger violations
+        for i in range(3):
+            enforce_orchestrator_mode("Edit", {"file_path": f"test{i}.py"})
+
+        assert manager.get_violation_count() == 3
+
+        # Re-enable should NOT reset (violations are session-specific)
+        # This test documents current behavior - violations persist across enable calls
+        manager.enable(level="strict")
+        assert manager.get_violation_count() == 3  # Violations persist
+
+
+class TestCircuitBreakerCLI:
+    """Test CLI commands for circuit breaker."""
+
+    def test_reset_violations_command_requires_enabled_mode(
+        self, tmp_path, monkeypatch, capsys
+    ):
+        """Test reset-violations fails gracefully when mode disabled."""
+        from argparse import Namespace
+
+        from htmlgraph.cli import cmd_orchestrator_reset_violations
+
+        # Don't enable mode - just test CLI error handling
+        args = Namespace(graph_dir=tmp_path / ".htmlgraph")
+        cmd_orchestrator_reset_violations(args)
+
+        captured = capsys.readouterr()
+        assert "not enabled" in captured.out.lower()
+
+    def test_reset_violations_command_success(self, tmp_path, monkeypatch, capsys):
+        """Test reset-violations command works."""
+        from argparse import Namespace
+
+        from htmlgraph.cli import cmd_orchestrator_reset_violations
+
+        monkeypatch.chdir(tmp_path)
+
+        manager = OrchestratorModeManager(tmp_path / ".htmlgraph")
+        manager.enable(level="strict")
+
+        # Add violations
+        for i in range(3):
+            enforce_orchestrator_mode("Edit", {"file_path": f"test{i}.py"})
+
+        # Reset via CLI
+        args = Namespace(graph_dir=tmp_path / ".htmlgraph")
+        cmd_orchestrator_reset_violations(args)
+
+        captured = capsys.readouterr()
+        assert "reset" in captured.out.lower()
+        assert manager.get_violation_count() == 0
+
+    def test_set_level_command(self, tmp_path, capsys):
+        """Test set-level command works."""
+        from argparse import Namespace
+
+        from htmlgraph.cli import cmd_orchestrator_set_level
+
+        manager = OrchestratorModeManager(tmp_path / ".htmlgraph")
+        manager.enable(level="strict")
+
+        # Change to guidance
+        args = Namespace(graph_dir=tmp_path / ".htmlgraph", level="guidance")
+        cmd_orchestrator_set_level(args)
+
+        captured = capsys.readouterr()
+        assert "guidance" in captured.out.lower()
+        assert manager.get_enforcement_level() == "guidance"
+
+    def test_status_shows_violations(self, tmp_path, monkeypatch, capsys):
+        """Test status command shows violation info."""
+        from argparse import Namespace
+
+        from htmlgraph.cli import cmd_orchestrator_status
+
+        monkeypatch.chdir(tmp_path)
+
+        manager = OrchestratorModeManager(tmp_path / ".htmlgraph")
+        manager.enable(level="strict")
+
+        # Add violations
+        enforce_orchestrator_mode("Edit", {"file_path": "test1.py"})
+        enforce_orchestrator_mode("Edit", {"file_path": "test2.py"})
+
+        args = Namespace(graph_dir=tmp_path / ".htmlgraph")
+        cmd_orchestrator_status(args)
+
+        captured = capsys.readouterr()
+        assert "2/3" in captured.out