titan-cli 0.1.4__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/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/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

titan_cli/ui/tui/textual_components.py

@@ -209,6 +209,46 @@ class TextualComponents:
         """
         self.app = app
         self.output_widget = output_widget
+        self._active_step_container = None
+
+    def begin_step(self, step_name: str) -> None:
+        """
+        Begin a new step by creating a StepContainer.
+
+        Args:
+            step_name: Name of the step
+        """
+        from titan_cli.ui.tui.widgets import StepContainer
+
+        def _create_container():
+            container = StepContainer(step_name=step_name)
+            self.output_widget.mount(container)
+            self._active_step_container = container
+
+        try:
+            self.app.call_from_thread(_create_container)
+        except Exception:
+            pass
+
+    def end_step(self, result_type: str) -> None:
+        """
+        End the current step by updating its container color.
+
+        Args:
+            result_type: One of 'success', 'skip', 'error'
+        """
+        if not self._active_step_container:
+            return
+
+        def _update_container():
+            if self._active_step_container:
+                self._active_step_container.set_result(result_type)
+                self._active_step_container = None
+
+        try:
+            self.app.call_from_thread(_update_container)
+        except Exception:
+            pass
 
     def mount(self, widget: Widget) -> None:
         """
@@ -222,7 +262,9 @@ class TextualComponents:
             ctx.textual.mount(Panel("Success!", panel_type="success"))
         """
         def _mount():
-            self.output_widget.mount(widget)
+            # Mount to active step container if it exists, otherwise to output widget
+            target = self._active_step_container if self._active_step_container else self.output_widget
+            target.mount(widget)
 
         # call_from_thread already blocks until the function completes
         try:
@@ -244,10 +286,20 @@ class TextualComponents:
             ctx.textual.text("Done!")
         """
         def _append():
-            if markup:
-                self.output_widget.append_output(f"[{markup}]{text}[/{markup}]")
+            # If there's an active step container, append to it; otherwise to output widget
+            if self._active_step_container:
+                from textual.widgets import Static
+                if markup:
+                    widget = Static(f"[{markup}]{text}[/{markup}]")
+                else:
+                    widget = Static(text)
+                widget.styles.height = "auto"
+                self._active_step_container.mount(widget)
             else:
-                self.output_widget.append_output(text)
+                if markup:
+                    self.output_widget.append_output(f"[{markup}]{text}[/{markup}]")
+                else:
+                    self.output_widget.append_output(text)
 
         # call_from_thread already blocks until the function completes
         try:
@@ -276,8 +328,9 @@ class TextualComponents:
         md_widget.styles.margin = (0, 0, 1, 0)
 
         def _mount():
-            # Mount markdown to output
-            self.output_widget.mount(md_widget)
+            # Mount to active step container if it exists, otherwise to output widget
+            target = self._active_step_container if self._active_step_container else self.output_widget
+            target.mount(md_widget)
             # Trigger autoscroll after mounting
             self.output_widget._scroll_to_end()
 

titan_cli/ui/tui/textual_workflow_executor.py

@@ -341,6 +341,14 @@ class TextualWorkflowExecutor:
                     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)
@@ -382,7 +390,7 @@ class TextualWorkflowExecutor:
                 # 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)
 
     def _execute_command_step(self, step_config: WorkflowStepModel, ctx: WorkflowContext) -> WorkflowResult:

titan_cli/ui/tui/widgets/__init__.py

@@ -8,6 +8,7 @@ from .header import HeaderWidget
 from .panel import Panel
 from .table import Table
 from .button import Button
+from .step_container import StepContainer
 from .text import (
     Text,
     DimText,
@@ -27,6 +28,7 @@ __all__ = [
     "Panel",
     "Table",
     "Button",
+    "StepContainer",
     "Text",
     "DimText",
     "BoldText",

titan_cli/ui/tui/widgets/step_container.py

@@ -0,0 +1,70 @@
+"""
+Step Container Widget
+
+A container that groups all output from a workflow step, with a titled border
+that changes color based on the step result (success, skip, error).
+"""
+from textual.containers import VerticalScroll
+
+
+class StepContainer(VerticalScroll):
+    """
+    Container for step output with colored border and title.
+
+    The border color changes based on step result:
+    - Running: cyan (default)
+    - Success: green
+    - Skip: yellow
+    - Error: red
+    """
+
+    DEFAULT_CSS = """
+    StepContainer {
+        width: 100%;
+        height: auto;
+        border: round $accent;
+        padding: 1 2;
+        margin: 1 0;
+    }
+
+    StepContainer.running {
+        border: round $accent;
+    }
+
+    StepContainer.success {
+        border: round $success;
+    }
+
+    StepContainer.skip {
+        border: round $warning;
+    }
+
+    StepContainer.error {
+        border: round $error;
+    }
+
+    StepContainer > Static {
+        color: initial;
+    }
+    """
+
+    def __init__(self, step_name: str, **kwargs):
+        super().__init__(**kwargs)
+        self.border_title = step_name
+        self.add_class("running")
+
+    def set_result(self, result_type: str):
+        """
+        Update the border color based on step result.
+
+        Args:
+            result_type: One of 'success', 'skip', 'error'
+        """
+        # Remove all result classes
+        self.remove_class("running", "success", "skip", "error")
+
+        # Add the new result class
+        if result_type in ["success", "skip", "error"]:
+            self.add_class(result_type)
+        else:
+            self.add_class("running")