titan-cli 0.1.3__py3-none-any.whl → 0.1.5__py3-none-any.whl

titan_cli/core/config.py

@@ -4,7 +4,7 @@ from typing import Optional, List
 import tomli
 from .models import TitanConfigModel
 from .plugins.plugin_registry import PluginRegistry
-from .workflows import WorkflowRegistry, ProjectStepSource
+from .workflows import WorkflowRegistry, ProjectStepSource, UserStepSource
 from .secrets import SecretManager
 from .errors import ConfigParseError, ConfigWriteError
 
@@ -75,10 +75,12 @@ class TitanConfig:
         # Use current working directory for workflows
         workflow_path = Path.cwd()
         project_step_source = ProjectStepSource(project_root=workflow_path)
+        user_step_source = UserStepSource()
         self._workflow_registry = WorkflowRegistry(
             project_root=workflow_path,
             plugin_registry=self.registry,
             project_step_source=project_step_source,
+            user_step_source=user_step_source,
             config=self
         )
 

titan_cli/core/plugins/models.py

@@ -30,15 +30,43 @@ class JiraPluginConfig(BaseModel):
     Credentials (base_url, email, api_token) should be configured at global level (~/.titan/config.toml).
     Project-specific settings (default_project) can override at project level (.titan/config.toml).
     """
-    base_url: Optional[str] = Field(None, description="JIRA instance URL (e.g., 'https://jira.company.com')")
-    email: Optional[str] = Field(None, description="User email for authentication")
+    base_url: Optional[str] = Field(
+        None,
+        description="JIRA instance URL (e.g., 'https://jira.company.com')",
+        json_schema_extra={"config_scope": "global"}
+    )
+    email: Optional[str] = Field(
+        None,
+        description="User email for authentication",
+        json_schema_extra={"config_scope": "global"}
+    )
     # api_token is stored in secrets, not in config.toml
     # It appears in the JSON schema for interactive configuration but is optional in the model
-    api_token: Optional[str] = Field(None, description="JIRA API token (Personal Access Token)", json_schema_extra={"format": "password", "required_in_schema": True})
-    default_project: Optional[str] = Field(None, description="Default JIRA project key (e.g., 'ECAPP', 'PROJ')")
-    timeout: int = Field(30, description="Request timeout in seconds")
-    enable_cache: bool = Field(True, description="Enable caching for API responses")
-    cache_ttl: int = Field(300, description="Cache time-to-live in seconds")
+    api_token: Optional[str] = Field(
+        None,
+        description="JIRA API token (Personal Access Token)",
+        json_schema_extra={"format": "password", "required_in_schema": True}
+    )
+    default_project: Optional[str] = Field(
+        None,
+        description="Default JIRA project key (e.g., 'ECAPP', 'PROJ')",
+        json_schema_extra={"config_scope": "project"}
+    )
+    timeout: int = Field(
+        30,
+        description="Request timeout in seconds",
+        json_schema_extra={"config_scope": "global"}
+    )
+    enable_cache: bool = Field(
+        True,
+        description="Enable caching for API responses",
+        json_schema_extra={"config_scope": "global"}
+    )
+    cache_ttl: int = Field(
+        300,
+        description="Cache time-to-live in seconds",
+        json_schema_extra={"config_scope": "global"}
+    )
 
     @field_validator('base_url')
     @classmethod

titan_cli/core/plugins/plugin_registry.py

@@ -20,10 +20,19 @@ class PluginRegistry:
         logger = logging.getLogger('titan_cli.ui.tui.screens.project_setup_wizard')
 
         discovered = entry_points(group='titan.plugins')
-        self._discovered_plugin_names = [ep.name for ep in discovered]
-        logger.debug(f"PluginRegistry.discover() - Found {len(self._discovered_plugin_names)} plugins: {self._discovered_plugin_names}")
 
+        # Deduplicate entry points (can happen in dev mode with editable installs)
+        seen = {}
+        unique_eps = []
         for ep in discovered:
+            if ep.name not in seen:
+                seen[ep.name] = ep
+                unique_eps.append(ep)
+
+        self._discovered_plugin_names = [ep.name for ep in unique_eps]
+        logger.debug(f"PluginRegistry.discover() - Found {len(self._discovered_plugin_names)} plugins: {self._discovered_plugin_names}")
+
+        for ep in unique_eps:
             try:
                 logger.debug(f"Loading plugin: {ep.name}")
                 plugin_class = ep.load()

titan_cli/core/workflows/__init__.py

@@ -10,7 +10,7 @@ Similar to plugins system, but for workflows:
 from .workflow_registry import WorkflowRegistry, ParsedWorkflow
 from .workflow_sources import WorkflowInfo
 from .workflow_exceptions import WorkflowNotFoundError, WorkflowExecutionError
-from .project_step_source import ProjectStepSource
+from .project_step_source import ProjectStepSource, UserStepSource
 
 __all__ = [
     "WorkflowRegistry",
@@ -19,4 +19,5 @@ __all__ = [
     "WorkflowNotFoundError",
     "WorkflowExecutionError",
     "ProjectStepSource",
+    "UserStepSource",
 ]

titan_cli/core/workflows/project_step_source.py

@@ -17,18 +17,17 @@ class StepInfo:
     name: str
     path: Path
     
-class ProjectStepSource:
+class BaseStepSource:
     """
-    Discovers and loads Python step functions from a project's .titan/steps/ directory.
+    Base class for discovering and loading Python step functions.
     """
-    def __init__(self, project_root: Path):
-        self._project_root = project_root
-        self._steps_dir = self._project_root / ".titan" / "steps"
+    EXCLUDED_FILES = {"__init__.py", "__pycache__"}
+
+    def __init__(self, steps_dir: Path):
+        self._steps_dir = steps_dir
         self._step_info_cache: Optional[List[StepInfo]] = None
         self._step_function_cache: Dict[str, StepFunction] = {}
 
-    EXCLUDED_FILES = {"__init__.py", "__pycache__"}
-
     def discover(self) -> List[StepInfo]:
         """
         Discovers all available step files in the project's .titan/steps directory.
@@ -52,35 +51,54 @@ class ProjectStepSource:
     def get_step(self, step_name: str) -> Optional[StepFunction]:
         """
         Retrieves a step function by name, loading it from its file if necessary.
+        Searches all Python files in the directory for the function.
         """
         if step_name in self._step_function_cache:
             return self._step_function_cache[step_name]
 
-        # Find the step info from the discovered list
-        discovered_steps = self.discover()
-        step_info = next((s for s in discovered_steps if s.name == step_name), None)
-
-        if not step_info:
+        if not self._steps_dir.is_dir():
             return None
 
-        try:
-            spec = importlib.util.spec_from_file_location(step_name, step_info.path)
-            if spec and spec.loader:
-                module = importlib.util.module_from_spec(spec)
-                spec.loader.exec_module(module)
-                
-                # Convention: the step function has the same name as the file
-                step_func = getattr(module, step_name, None)
-                if callable(step_func):
-                    self._step_function_cache[step_name] = step_func
-                    return step_func
-                else:
-                    # Optional: Log a warning if a file exists but the function doesn't
-                    pass
-                    
-        except Exception as e:
-            # Optional: Log a more detailed error
-            print(f"Error loading project step '{step_name}': {e}")
+        # Search all Python files for the function
+        for step_file in self._steps_dir.glob("*.py"):
+            if step_file.name in self.EXCLUDED_FILES:
+                continue
+
+            try:
+                # Use a unique module name to avoid conflicts
+                module_name = f"_titan_step_{step_file.stem}_{id(step_file)}"
+                spec = importlib.util.spec_from_file_location(module_name, step_file)
+                if spec and spec.loader:
+                    module = importlib.util.module_from_spec(spec)
+                    spec.loader.exec_module(module)
+
+                    # Look for the function in this module
+                    step_func = getattr(module, step_name, None)
+                    if callable(step_func):
+                        self._step_function_cache[step_name] = step_func
+                        return step_func
+
+            except Exception:
+                # Continue searching other files
+                continue
 
         return None
 
+
+class ProjectStepSource(BaseStepSource):
+    """
+    Discovers and loads Python step functions from a project's .titan/steps/ directory.
+    """
+    def __init__(self, project_root: Path):
+        steps_dir = project_root / ".titan" / "steps"
+        super().__init__(steps_dir)
+        self._project_root = project_root
+
+
+class UserStepSource(BaseStepSource):
+    """
+    Discovers and loads Python step functions from user's ~/.titan/steps/ directory.
+    """
+    def __init__(self):
+        steps_dir = Path.home() / ".titan" / "steps"
+        super().__init__(steps_dir)

titan_cli/core/workflows/workflow_filter_service.py

@@ -36,15 +36,21 @@ class WorkflowFilterService:
             plugin_name = wf_info.source.split(":", 1)[1]
             return plugin_name.capitalize()
 
-        # For project/user workflows, check which plugin they use
-        if wf_info.source in ["project", "user"]:
+        # User workflows always go to "Personal" category
+        if wf_info.source == "user":
+            return "Personal"
+
+        # For project workflows, check which plugin they use
+        if wf_info.source == "project":
             if wf_info.required_plugins:
-                # Use the first required plugin (most workflows use only one)
-                primary_plugin = sorted(wf_info.required_plugins)[0]
-                return primary_plugin.capitalize()
-            else:
-                # No plugin dependencies, it's a custom workflow
-                return "Custom"
+                # Filter out core/project pseudo-plugins
+                real_plugins = [p for p in wf_info.required_plugins if p not in ["core", "project"]]
+                if real_plugins:
+                    # Use the first real plugin
+                    primary_plugin = sorted(real_plugins)[0]
+                    return primary_plugin.capitalize()
+            # No plugin dependencies, it's a custom workflow
+            return "Custom"
 
         # Fallback for other sources
         return wf_info.source.capitalize()

titan_cli/core/workflows/workflow_registry.py

@@ -7,7 +7,7 @@ from dataclasses import dataclass
 from copy import deepcopy
 
 from titan_cli.core.plugins.plugin_registry import PluginRegistry
-from titan_cli.core.workflows.project_step_source import ProjectStepSource, StepFunction
+from titan_cli.core.workflows.project_step_source import ProjectStepSource, UserStepSource, StepFunction
 
 from .workflow_sources import (
     WorkflowSource,
@@ -48,6 +48,7 @@ class WorkflowRegistry:
         project_root: Path,
         plugin_registry: PluginRegistry,
         project_step_source: ProjectStepSource,
+        user_step_source: UserStepSource = None,
         config: Any = None
     ):
         """
@@ -57,11 +58,13 @@ class WorkflowRegistry:
             project_root: Root path of the current project.
             plugin_registry: Registry of installed plugins.
             project_step_source: Source for discovering project-specific steps.
+            user_step_source: Source for discovering user-specific steps (~/.titan/steps/).
             config: TitanConfig instance (optional, for filtering by enabled plugins).
         """
         self.project_root = project_root
         self.plugin_registry = plugin_registry
         self._project_step_source = project_step_source
+        self._user_step_source = user_step_source
         self._config = config
 
         # Define the base path for system workflows, assuming it's in the root of the package
@@ -416,4 +419,12 @@ class WorkflowRegistry:
         """
         return self._project_step_source.get_step(step_name)
 
+    def get_user_step(self, step_name: str) -> Optional[StepFunction]:
+        """
+        Retrieves a loaded user step function by its name from the user step source.
+        """
+        if self._user_step_source:
+            return self._user_step_source.get_step(step_name)
+        return None
+
 

titan_cli/core/workflows/workflow_sources.py

@@ -45,7 +45,7 @@ def _parse_workflow_info(file: Path, source_name: str, plugin_registry: PluginRe
     steps = config.get("steps", [])
     if isinstance(steps, list):
         for step in steps:
-            if isinstance(step, dict) and "plugin" in step and step["plugin"] not in ["core", "project"]:
+            if isinstance(step, dict) and "plugin" in step and step["plugin"] not in ["core", "project", "user"]:
                 required_plugins.add(step["plugin"])
 
     # Check 'extends' field for plugin dependencies

titan_cli/engine/steps/ai_assistant_step.py

@@ -8,7 +8,7 @@ Can be used after linting, testing, builds, or any step that produces
 errors or context that could benefit from AI assistance.
 """
 
-import json 
+import json
 
 from titan_cli.core.workflows.models import WorkflowStepModel
 from titan_cli.engine.context import WorkflowContext
@@ -43,6 +43,9 @@ def execute_ai_assistant_step(step: WorkflowStepModel, ctx: WorkflowContext) ->
     if not ctx.textual:
         return Error(msg.AIAssistant.UI_CONTEXT_NOT_AVAILABLE)
 
+    # Begin step container - use step name from workflow
+    ctx.textual.begin_step(step.name or "AI Code Assistant")
+
     # Get parameters
     context_key = step.params.get("context_key")
     prompt_template = step.params.get("prompt_template", "{context}")
@@ -53,17 +56,32 @@ def execute_ai_assistant_step(step: WorkflowStepModel, ctx: WorkflowContext) ->
     # Validate cli_preference
     VALID_CLI_PREFERENCES = {"auto", "claude", "gemini"}
     if cli_preference not in VALID_CLI_PREFERENCES:
+        ctx.textual.text(f"Invalid cli_preference: {cli_preference}. Must be one of {VALID_CLI_PREFERENCES}", markup="red")
+        ctx.textual.end_step("error")
         return Error(f"Invalid cli_preference: {cli_preference}. Must be one of {VALID_CLI_PREFERENCES}")
 
     # Validate required parameters
     if not context_key:
+        ctx.textual.text(msg.AIAssistant.CONTEXT_KEY_REQUIRED, markup="red")
+        ctx.textual.end_step("error")
         return Error(msg.AIAssistant.CONTEXT_KEY_REQUIRED)
 
     # Get context data
     context_data = ctx.data.get(context_key)
     if not context_data:
-        # No context to work with - skip silently
-        return Skip(msg.AIAssistant.NO_DATA_IN_CONTEXT.format(context_key=context_key))
+        # No context to work with - skip silently with user-friendly message
+        # Infer what we're skipping based on step name
+        step_name = step.name or "AI Code Assistant"
+        if "lint" in step_name.lower():
+            friendly_msg = "No linting issues found - skipping AI assistance"
+        elif "test" in step_name.lower():
+            friendly_msg = "No test failures found - skipping AI assistance"
+        else:
+            friendly_msg = "No issues to fix - skipping AI assistance"
+
+        ctx.textual.text(friendly_msg, markup="dim")
+        ctx.textual.end_step("skip")
+        return Skip(friendly_msg)
 
     # Clear the context data immediately to prevent contamination of subsequent steps
     if context_key in ctx.data:
@@ -78,8 +96,12 @@ def execute_ai_assistant_step(step: WorkflowStepModel, ctx: WorkflowContext) ->
             context_str = json.dumps(context_data, indent=2)
             prompt = prompt_template.format(context=context_str)
     except KeyError as e:
+        ctx.textual.text(msg.AIAssistant.INVALID_PROMPT_TEMPLATE.format(e=e), markup="red")
+        ctx.textual.end_step("error")
         return Error(msg.AIAssistant.INVALID_PROMPT_TEMPLATE.format(e=e))
     except Exception as e:
+        ctx.textual.text(msg.AIAssistant.FAILED_TO_BUILD_PROMPT.format(e=e), markup="red")
+        ctx.textual.end_step("error")
         return Error(msg.AIAssistant.FAILED_TO_BUILD_PROMPT.format(e=e))
 
     # Ask for confirmation if needed
@@ -91,7 +113,11 @@ def execute_ai_assistant_step(step: WorkflowStepModel, ctx: WorkflowContext) ->
         )
         if not should_launch:
             if fail_on_decline:
+                ctx.textual.text(msg.AIAssistant.DECLINED_ASSISTANCE_STOPPED, markup="yellow")
+                ctx.textual.end_step("error")
                 return Error(msg.AIAssistant.DECLINED_ASSISTANCE_STOPPED)
+            ctx.textual.text(msg.AIAssistant.DECLINED_ASSISTANCE_SKIPPED, markup="dim")
+            ctx.textual.end_step("skip")
             return Skip(msg.AIAssistant.DECLINED_ASSISTANCE_SKIPPED)
 
     # Determine which CLI to use
@@ -116,8 +142,8 @@ def execute_ai_assistant_step(step: WorkflowStepModel, ctx: WorkflowContext) ->
                 available_launchers[cli_name] = launcher
 
     if not available_launchers:
-        from titan_cli.ui.tui.widgets import Panel
-        ctx.textual.mount(Panel(msg.AIAssistant.NO_ASSISTANT_CLI_FOUND, panel_type="warning"))
+        ctx.textual.text(msg.AIAssistant.NO_ASSISTANT_CLI_FOUND, markup="yellow")
+        ctx.textual.end_step("skip")
         return Skip(msg.AIAssistant.NO_ASSISTANT_CLI_FOUND)
 
     if len(available_launchers) == 1:
@@ -136,6 +162,8 @@ def execute_ai_assistant_step(step: WorkflowStepModel, ctx: WorkflowContext) ->
         choice_str = ctx.textual.ask_text("Select option (or press Enter to cancel):", default="")
 
         if not choice_str or choice_str.strip() == "":
+            ctx.textual.text(msg.AIAssistant.DECLINED_ASSISTANCE_SKIPPED, markup="dim")
+            ctx.textual.end_step("skip")
             return Skip(msg.AIAssistant.DECLINED_ASSISTANCE_SKIPPED)
 
         try:
@@ -144,19 +172,22 @@ def execute_ai_assistant_step(step: WorkflowStepModel, ctx: WorkflowContext) ->
                 cli_to_launch = cli_options[choice_idx]
             else:
                 ctx.textual.text("Invalid option selected", markup="red")
+                ctx.textual.end_step("skip")
                 return Skip(msg.AIAssistant.DECLINED_ASSISTANCE_SKIPPED)
         except ValueError:
             ctx.textual.text("Invalid input - must be a number", markup="red")
+            ctx.textual.end_step("skip")
             return Skip(msg.AIAssistant.DECLINED_ASSISTANCE_SKIPPED)
 
     # Validate selection
     if cli_to_launch not in available_launchers:
+        ctx.textual.text(f"Unknown CLI to launch: {cli_to_launch}", markup="red")
+        ctx.textual.end_step("error")
         return Error(f"Unknown CLI to launch: {cli_to_launch}")
 
     cli_name = CLI_REGISTRY[cli_to_launch].get("display_name", cli_to_launch)
 
     # Launch the CLI
-    from titan_cli.ui.tui.widgets import Panel
     ctx.textual.text("")  # spacing
     ctx.textual.text(msg.AIAssistant.LAUNCHING_ASSISTANT.format(cli_name=cli_name), markup="cyan")
 
@@ -177,9 +208,13 @@ def execute_ai_assistant_step(step: WorkflowStepModel, ctx: WorkflowContext) ->
     )
 
     ctx.textual.text("")  # spacing
-    ctx.textual.mount(Panel(msg.AIAssistant.BACK_IN_TITAN, panel_type="success"))
+    ctx.textual.text(msg.AIAssistant.BACK_IN_TITAN, markup="green")
 
     if exit_code != 0:
+        ctx.textual.text(msg.AIAssistant.ASSISTANT_EXITED_WITH_CODE.format(cli_name=cli_name, exit_code=exit_code), markup="yellow")
+        ctx.textual.end_step("error")
         return Error(msg.AIAssistant.ASSISTANT_EXITED_WITH_CODE.format(cli_name=cli_name, exit_code=exit_code))
 
+    ctx.textual.text(msg.AIAssistant.ASSISTANT_EXITED_WITH_CODE.format(cli_name=cli_name, exit_code=exit_code), markup="green")
+    ctx.textual.end_step("success")
     return Success(msg.AIAssistant.ASSISTANT_EXITED_WITH_CODE.format(cli_name=cli_name, exit_code=exit_code), metadata={"ai_exit_code": exit_code})

titan_cli/engine/workflow_executor.py

@@ -128,6 +128,11 @@ class WorkflowExecutor:
             step_func = self._workflow_registry.get_project_step(step_func_name)
             if not step_func:
                 return Error(f"Project step '{step_func_name}' not found in '.titan/steps/'.", WorkflowExecutionError(f"Project step '{step_func_name}' not found"))
+        elif plugin_name == "user":
+            # Handle virtual 'user' plugin for user-specific steps
+            step_func = self._workflow_registry.get_user_step(step_func_name)
+            if not step_func:
+                return Error(f"User step '{step_func_name}' not found in '~/.titan/steps/'.", WorkflowExecutionError(f"User step '{step_func_name}' not found"))
         elif plugin_name == "core":
             # Handle virtual 'core' plugin for built-in core steps
             step_func = self.CORE_STEPS.get(step_func_name)
@@ -160,7 +165,7 @@ class WorkflowExecutor:
                 # Plugin and project steps receive only ctx (params are in ctx.data)
                 return step_func(ctx)
         except Exception as e:
-            error_source = f"plugin '{plugin_name}'" if plugin_name not in ("project", "core") else f"{plugin_name} step"
+            error_source = f"plugin '{plugin_name}'" if plugin_name not in ("project", "user", "core") else f"{plugin_name} step"
             return Error(f"Error executing step '{step_func_name}' from {error_source}: {e}", e)
 
 

titan_cli/ui/tui/screens/plugin_config_wizard.py

@@ -494,22 +494,43 @@ class PluginConfigWizardScreen(BaseScreen):
 
         try:
             project_cfg_path = self.config.project_config_path
+            global_cfg_path = self.config._global_config_path
+
             if not project_cfg_path:
                 self.app.notify("No project config found", severity="error")
                 return
 
+            # Load existing configs
             project_cfg_dict = {}
             if project_cfg_path.exists():
                 with open(project_cfg_path, "rb") as f:
                     project_cfg_dict = tomli.load(f)
 
-            plugins_table = project_cfg_dict.setdefault("plugins", {})
-            plugin_specific_table = plugins_table.setdefault(self.plugin_name, {})
-            plugin_config_table = plugin_specific_table.setdefault("config", {})
+            global_cfg_dict = {}
+            if global_cfg_path.exists():
+                with open(global_cfg_path, "rb") as f:
+                    global_cfg_dict = tomli.load(f)
+
+            # Prepare plugin tables
+            project_plugins_table = project_cfg_dict.setdefault("plugins", {})
+            project_plugin_table = project_plugins_table.setdefault(self.plugin_name, {})
+            project_config_table = project_plugin_table.setdefault("config", {})
+
+            global_plugins_table = global_cfg_dict.setdefault("plugins", {})
+            global_plugin_table = global_plugins_table.setdefault(self.plugin_name, {})
+            global_config_table = global_plugin_table.setdefault("config", {})
 
-            # Separate secrets from regular config
+            # Get field metadata from schema
+            field_scopes = {}
+            if self.schema and "properties" in self.schema:
+                for field_name, field_info in self.schema["properties"].items():
+                    scope = field_info.get("config_scope", "project")  # Default to project
+                    field_scopes[field_name] = scope
+
+            # Separate secrets and config by scope
             secrets_to_save = {}
-            config_values = {}
+            global_config_values = {}
+            project_config_values = {}
 
             for field_name, value in self.config_data.items():
                 if isinstance(value, dict) and value.get("_is_secret"):
@@ -524,15 +545,25 @@ class PluginConfigWizardScreen(BaseScreen):
                     else:
                         secrets_to_save[secret_key] = value["_value"]
                 else:
-                    config_values[field_name] = value
+                    # Route to global or project based on field scope
+                    scope = field_scopes.get(field_name, "project")
+                    if scope == "global":
+                        global_config_values[field_name] = value
+                    else:
+                        project_config_values[field_name] = value
 
-            # Update config
-            plugin_config_table.update(config_values)
+            # Update configs
+            project_config_table.update(project_config_values)
+            global_config_table.update(global_config_values)
 
-            # Write config file
+            # Write config files
             with open(project_cfg_path, "wb") as f:
                 tomli_w.dump(project_cfg_dict, f)
 
+            if global_config_values:  # Only write global if there are global values
+                with open(global_cfg_path, "wb") as f:
+                    tomli_w.dump(global_cfg_dict, f)
+
             # Save secrets
             project_name = self.config.get_project_name()
             for secret_key, secret_value in secrets_to_save.items():

titan_cli/ui/tui/screens/workflow_execution.py

@@ -504,7 +504,6 @@ class WorkflowExecutionContent(Widget):
     def handle_event(self, message) -> None:
         """Handle workflow events generically."""
         from titan_cli.ui.tui.textual_workflow_executor import TextualWorkflowExecutor
-        from titan_cli.ui.tui.widgets import Panel
 
         if isinstance(message, TextualWorkflowExecutor.WorkflowStarted):
             # Track nested workflow depth
@@ -513,31 +512,16 @@ class WorkflowExecutionContent(Widget):
             self.append_output(f"\n[bold cyan]🚀 Starting workflow: {message.workflow_name}[/bold cyan]")
 
         elif isinstance(message, TextualWorkflowExecutor.StepStarted):
-            # Format differently for nested workflows
-            if self._workflow_depth > 0:
-                # Nested workflow: show with indentation, no step number
-                indent = "  " * self._workflow_depth
-                self.append_output(f"[cyan]{indent}→ Step {message.step_index}: {message.step_name}[/cyan]")
-            else:
-                # Top-level workflow: show with step number
-                self.append_output(f"[cyan]→ Step {message.step_index}: {message.step_name}[/cyan]")
+            # StepContainer now handles step titles, so we don't display anything here
+            pass
 
         elif isinstance(message, TextualWorkflowExecutor.StepCompleted):
-            # Apply indentation for nested workflows
-            if self._workflow_depth > 0:
-                indent = "  " * self._workflow_depth
-                self.append_output(f"[green]{indent}{Icons.SUCCESS} Completed: {message.step_name}[/green]\n")
-            else:
-                self.append_output(f"[green]{Icons.SUCCESS} Completed: {message.step_name}[/green]\n")
+            # StepContainer now handles step completion (green border), so we don't display anything here
+            pass
 
         elif isinstance(message, TextualWorkflowExecutor.StepFailed):
-            # Mount error panel
-            try:
-                self.mount(Panel(f"Failed: {message.step_name} - {message.error_message}", panel_type="error"))
-                self._scroll_to_end()
-            except Exception:
-                pass
-
+            # StepContainer now handles step failures (red border), so we don't display the panel
+            # Only show "continuing despite error" message if on_error is "continue"
             if message.on_error == "continue":
                 indent = "  " * self._workflow_depth if self._workflow_depth > 0 else ""
                 self.append_output(f"[yellow]{indent}   {Icons.WARNING}  Continuing despite error[/yellow]\n")
@@ -545,12 +529,8 @@ class WorkflowExecutionContent(Widget):
                 self.append_output("")
 
         elif isinstance(message, TextualWorkflowExecutor.StepSkipped):
-            # Mount warning panel for skipped steps
-            try:
-                self.mount(Panel(f"Skipped: {message.step_name}", panel_type="warning"))
-                self._scroll_to_end()
-            except Exception:
-                pass
+            # StepContainer now handles step skips (yellow border), so we don't display the panel
+            pass
 
         elif isinstance(message, TextualWorkflowExecutor.WorkflowCompleted):
             # Track nested workflow depth