fix: wire orb config show missing sections, fix fleetRole ARN expansion, add scheduler mismatch flag

orb config show:
- Add get_scripts_dir() to ConfigurationPort/ConfigurationAdapter
- scripts_dir, template_search_paths, logging, request_limits, backup_path, data_path all wired
- grace_period and circuit_breaker defaults wired
- Fix empty except clauses with debug logging
- Fix mismatch_action initialisation before try block

fleetRole:
- Short name expanded to full ARN from template or config

Scheduler mismatch:
- on_scheduler_mismatch: ignore|warn|fail flag added to SchedulerConfig
- _delegate_load_to_strategy enforces the flag
- _validate_basic_template_structure checks scheduler compatibility

Author: fgogolli

src/orb/application/dto/system.py

@@ -229,6 +229,7 @@ class PathsSectionDTO(BaseDTO):
     config_dir: str
     work_dir: str
     log_dir: str
+    scripts_dir: Optional[str] = None
     loaded_config_file: Optional[str] = None
     loaded_templates_file: Optional[str] = None
     template_search_paths: Optional[list[str]] = Field(default=None)

src/orb/application/queries/system_handlers.py

@@ -489,8 +489,7 @@ async def execute_query(self, query: GetSystemConfigQuery) -> SystemConfigDTO:
                     loaded_templates_file = path
                     break
 
-            if query.verbose:
-                template_search_paths = all_paths
+            template_search_paths = all_paths
         except Exception:  # noqa: BLE001 — template path resolution is best-effort; fall back to None
             pass
 
@@ -499,6 +498,7 @@ async def execute_query(self, query: GetSystemConfigQuery) -> SystemConfigDTO:
             config_dir=cfg.get_config_dir() if hasattr(cfg, "get_config_dir") else "",
             work_dir=cfg.get_work_dir() if hasattr(cfg, "get_work_dir") else "",
             log_dir=cfg.get_log_dir() if hasattr(cfg, "get_log_dir") else "",
+            scripts_dir=cfg.get_scripts_dir() if hasattr(cfg, "get_scripts_dir") else None,
             loaded_config_file=cast(Any, cfg).get_loaded_config_file()
             if hasattr(cfg, "get_loaded_config_file")
             else None,
@@ -554,35 +554,43 @@ async def execute_query(self, query: GetSystemConfigQuery) -> SystemConfigDTO:
                 port=server_cfg.get("port"),
             )
 
-        # --- verbose sections ---
+        # --- always-shown sections ---
+        log_cfg = cfg.get_logging_config() if hasattr(cfg, "get_logging_config") else {}
         logging_section: LoggingSectionDTO | None = None
+        if isinstance(log_cfg, dict):
+            logging_section = LoggingSectionDTO(
+                level=str(log_cfg.get("level", "INFO")),
+                log_file=log_cfg.get("file_path"),
+                console_enabled=bool(log_cfg.get("console_enabled", True)),
+            )
+
+        req_cfg = cfg.get_request_config() if hasattr(cfg, "get_request_config") else {}
         request_limits: RequestLimitsSectionDTO | None = None
-        circuit_breaker: CircuitBreakerSectionDTO | None = None
+        if isinstance(req_cfg, dict):
+            request_limits = RequestLimitsSectionDTO(
+                max_machines=req_cfg.get("max_machines_per_request"),
+                default_timeout=req_cfg.get("default_timeout"),
+                grace_period=req_cfg.get("default_grace_period"),
+            )
 
+        # --- verbose-only sections ---
+        circuit_breaker: CircuitBreakerSectionDTO | None = None
         if query.verbose:
-            log_cfg = cfg.get_logging_config() if hasattr(cfg, "get_logging_config") else {}
-            if isinstance(log_cfg, dict):
-                logging_section = LoggingSectionDTO(
-                    level=str(log_cfg.get("level", "INFO")),
-                    log_file=log_cfg.get("file"),
-                    console_enabled=bool(log_cfg.get("console_enabled", True)),
-                )
-
-            req_cfg = cfg.get_request_config() if hasattr(cfg, "get_request_config") else {}
-            if isinstance(req_cfg, dict):
-                request_limits = RequestLimitsSectionDTO(
-                    max_machines=req_cfg.get("max_machines_per_request"),
-                    default_timeout=req_cfg.get("default_timeout"),
-                    grace_period=req_cfg.get("grace_period"),
-                )
-
-            cb_cfg = cfg.get("circuit_breaker", {})
-            if isinstance(cb_cfg, dict):
+            try:
+                cb = cfg.app_config.circuit_breaker  # type: ignore[union-attr]
                 circuit_breaker = CircuitBreakerSectionDTO(
-                    enabled=bool(cb_cfg.get("enabled", False)),
-                    failure_threshold=cb_cfg.get("failure_threshold"),
-                    recovery_timeout=cb_cfg.get("recovery_timeout"),
+                    enabled=cb.enabled,
+                    failure_threshold=cb.failure_threshold,
+                    recovery_timeout=cb.recovery_timeout,
                 )
+            except Exception:  # noqa: BLE001
+                cb_cfg = cfg.get("circuit_breaker", {})
+                if isinstance(cb_cfg, dict):
+                    circuit_breaker = CircuitBreakerSectionDTO(
+                        enabled=bool(cb_cfg.get("enabled", True)),
+                        failure_threshold=cb_cfg.get("failure_threshold", 5),
+                        recovery_timeout=cb_cfg.get("recovery_timeout", 60),
+                    )
 
         return SystemConfigDTO(
             paths=paths,

src/orb/config/loader.py

@@ -457,7 +457,9 @@ def _process_scheduler_directories(
 
             # Propagate scripts_dir written by `orb init` back into the config model
             if "scripts_dir" in config and config["scripts_dir"]:
-                get_config_logger().debug("scripts_dir from config: %s", config["scripts_dir"])
+                scripts_dir = config["scripts_dir"]
+                get_config_logger().debug("scripts_dir from config: %s", scripts_dir)
+                os.environ.setdefault("ORB_SCRIPTS_DIR", scripts_dir)
 
             # Set up storage paths
             if scheduler_dir:

src/orb/config/schemas/scheduler_schema.py

@@ -24,6 +24,10 @@ class SchedulerConfig(BaseModel):
     templates_filename: Optional[str] = Field(
         None, description="Override templates filename (null = use scheduler default)"
     )
+    on_scheduler_mismatch: Literal["ignore", "warn", "fail"] = Field(
+        "warn",
+        description="Behaviour when a template's scheduler_type doesn't match the active scheduler",
+    )
 
     def get_config_root(self) -> str:
         """Get config root with automatic environment variable expansion."""

src/orb/domain/base/ports/configuration_port.py

@@ -176,6 +176,10 @@ def get_root_dir(self) -> str:
         """Get the root directory path."""
         return ""
 
+    def get_scripts_dir(self) -> str:
+        """Get the scripts directory path."""
+        return ""
+
     @property
     def app_config(self) -> Any:
         """Get the full application configuration."""

src/orb/infrastructure/adapters/configuration_adapter.py

@@ -91,7 +91,8 @@ def get_request_config(self) -> dict[str, Any]:
                 "max_machines_per_request": getattr(
                     request_config, "max_machines_per_request", 100
                 ),
-                "default_timeout": getattr(request_config, "default_timeout", 300),
+                "default_timeout": getattr(request_config, "default_timeout", 3600),
+                "default_grace_period": getattr(request_config, "default_grace_period", 300),
                 "min_timeout": getattr(request_config, "min_timeout", 30),
                 "max_timeout": getattr(request_config, "max_timeout", 3600),
                 "fulfillment_max_retries": request_config.fulfillment_max_retries,
@@ -103,7 +104,8 @@ def get_request_config(self) -> dict[str, Any]:
             self._logger.warning("Failed to load request config, using defaults: %s", e)
             return {
                 "max_machines_per_request": 100,
-                "default_timeout": 300,
+                "default_timeout": 3600,
+                "default_grace_period": 300,
                 "min_timeout": 30,
                 "max_timeout": 3600,
                 "fulfillment_max_retries": 3,
@@ -177,23 +179,52 @@ def get_root_dir(self) -> str:
 
         return str(get_root_location())
 
+    def get_scripts_dir(self) -> str:
+        """Get the scripts directory path."""
+        from orb.config.platform_dirs import get_scripts_location
+
+        return str(get_scripts_location())
+
     def get_storage_config(self) -> dict[str, Any]:
         """Get storage configuration."""
         try:
+            from pathlib import Path
+
             storage_config = self._config_manager.get("storage", {})
             strategy = storage_config.get("strategy", storage_config.get("type", "json"))
             if strategy == "json":
                 json_cfg = storage_config.get("json_strategy", {})
-                data_path = json_cfg.get("base_path")
+                raw_data_path = json_cfg.get("base_path")
                 backup_enabled = json_cfg.get("backup_enabled", True)
+                raw_backup_path = json_cfg.get("backup_path") or storage_config.get("backup_path")
             elif strategy == "sql":
                 sql_cfg = storage_config.get("sql_strategy", {})
-                data_path = sql_cfg.get("name")
+                raw_data_path = sql_cfg.get("name")
                 backup_enabled = False
+                raw_backup_path = storage_config.get("backup_path")
             else:
-                data_path = None
+                raw_data_path = None
                 backup_enabled = storage_config.get("backup_enabled", True)
-            backup_path = storage_config.get("backup_path")
+                raw_backup_path = storage_config.get("backup_path")
+
+            work_dir = Path(self._config_manager.get_work_dir())
+
+            # Resolve data_path to absolute
+            if raw_data_path:
+                p = Path(raw_data_path)
+                data_path = str(p if p.is_absolute() else work_dir / p)
+            else:
+                data_path = None
+
+            # Resolve backup_path; default to work_dir/backups
+            if raw_backup_path:
+                bp = Path(raw_backup_path)
+                backup_path = str(bp if bp.is_absolute() else work_dir / bp)
+            elif backup_enabled:
+                backup_path = str(work_dir / "backups")
+            else:
+                backup_path = None
+
             return {
                 "strategy": strategy,
                 "data_path": data_path,
@@ -231,6 +262,7 @@ def get_logging_config(self) -> dict[str, Any]:
                 "format": logging_config.get(
                     "format", "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
                 ),
+                "file_path": logging_config.get("file_path"),
                 "file_enabled": logging_config.get("file_enabled", True),
                 "console_enabled": logging_config.get("console_enabled", True),
             }
@@ -239,6 +271,7 @@ def get_logging_config(self) -> dict[str, Any]:
             return {
                 "level": "INFO",
                 "format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+                "file_path": None,
                 "file_enabled": True,
                 "console_enabled": True,
             }

src/orb/infrastructure/scheduler/base/strategy.py

@@ -372,10 +372,32 @@ def _delegate_load_to_strategy(
 
         registry = get_scheduler_registry()
         if not registry.is_registered(scheduler_type):
-            self.logger.warning(
-                "Scheduler type '%s' not registered, cannot delegate template loading",
-                scheduler_type,
-            )
+            mismatch_action = "warn"
+            if self._config_manager is not None:
+                try:
+                    mismatch_action = getattr(
+                        self._config_manager.app_config.scheduler,
+                        "on_scheduler_mismatch",
+                        "warn",
+                    )
+                except Exception as e:
+                    # Config unavailable — default to warn so mismatch doesn't hard-fail
+                    self.logger.debug("Could not read on_scheduler_mismatch config: %s", e)
+
+            if mismatch_action == "fail":
+                from orb.infrastructure.template.configuration_manager import (
+                    TemplateConfigurationError,
+                )
+
+                raise TemplateConfigurationError(
+                    f"Scheduler type '{scheduler_type}' not registered and on_scheduler_mismatch=fail"
+                )
+            elif mismatch_action == "warn":
+                self.logger.warning(
+                    "Scheduler type '%s' not registered, cannot delegate template loading",
+                    scheduler_type,
+                )
+            # "ignore" — suppress the warning entirely
             return None
 
         try:

src/orb/infrastructure/template/configuration_manager.py

@@ -581,6 +581,33 @@ def _validate_basic_template_structure(
                 "Max instances is very high (>1000), consider if this is intentional"
             )
 
+        # Check scheduler_type metadata mismatch
+        template_scheduler_type = (
+            template.metadata.get("scheduler_type") if isinstance(template.metadata, dict) else None
+        )
+        if template_scheduler_type is not None:
+            active_scheduler_type = None
+            mismatch_action = "warn"
+            try:
+                active_scheduler_type = self.config_manager.app_config.scheduler.type
+                mismatch_action = getattr(
+                    self.config_manager.app_config.scheduler, "on_scheduler_mismatch", "warn"
+                )
+            except Exception as e:
+                self.logger.debug("Could not read scheduler config for mismatch check: %s", e)
+
+            if active_scheduler_type and template_scheduler_type != active_scheduler_type:
+                msg = (
+                    f"Template '{template.template_id}' has scheduler_type "
+                    f"'{template_scheduler_type}' but active scheduler is '{active_scheduler_type}'"
+                )
+                if mismatch_action == "fail":
+                    result["is_valid"] = False
+                    result["errors"].append(msg)
+                elif mismatch_action == "warn":
+                    result["warnings"].append(msg)
+                # "ignore" — add nothing
+
         self.logger.debug("Basic validation completed for template %s", template.template_id)
 
     async def _validate_with_provider_registry(

src/orb/providers/aws/infrastructure/handlers/spot_fleet/handler.py

@@ -225,7 +225,10 @@ def _resolve_fleet_role(self, aws_template: AWSTemplate) -> AWSTemplate:
                 f"spotfleet.amazonaws.com/AWSServiceRoleForEC2SpotFleet"
             )
             self._logger.info("Converted EC2Fleet role to SpotFleet role: %s", resolved)
-        elif fleet_role == "AWSServiceRoleForEC2SpotFleet":
+        elif fleet_role in (
+            "AWSServiceRoleForEC2SpotFleet",
+            "AmazonEC2SpotFleetTaggingRole",
+        ):
             account_id = self.aws_client.sts_client.get_caller_identity()["Account"]
             resolved = (
                 f"arn:aws:iam::{account_id}:role/aws-service-role/"