titan-cli 0.1.4__py3-none-any.whl → 0.1.6__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

@@ -1,4 +1,5 @@
 import importlib.util
+import sys
 from pathlib import Path
 from typing import Callable, Dict, Any, Optional, List
 from dataclasses import dataclass
@@ -17,21 +18,21 @@ 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.
+        Supports subdirectories (e.g., .titan/steps/jira/step.py).
         """
         if self._step_info_cache is not None:
             return self._step_info_cache
@@ -41,46 +42,108 @@ class ProjectStepSource:
             return []
 
         discovered = []
-        for step_file in self._steps_dir.glob("*.py"):
-            if step_file.name not in self.EXCLUDED_FILES:
+        for step_file in self._steps_dir.glob("**/*.py"):
+            if step_file.name not in self.EXCLUDED_FILES and not any(part.startswith("__") for part in step_file.parts):
                 step_name = step_file.stem
                 discovered.append(StepInfo(name=step_name, path=step_file))
-        
+
         self._step_info_cache = discovered
         return discovered
 
     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 (including subdirectories) 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 self._steps_dir.is_dir():
+            return None
 
-        if not step_info:
+        # Search all Python files (including subdirectories) for the function
+        for step_file in self._steps_dir.glob("**/*.py"):
+            if step_file.name in self.EXCLUDED_FILES or any(part.startswith("__") for part in step_file.parts):
+                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.
+    Supports relative imports by properly setting module __package__ attribute.
+    """
+    def __init__(self, project_root: Path):
+        steps_dir = project_root / ".titan" / "steps"
+        super().__init__(steps_dir)
+        self._project_root = project_root
+        self._titan_dir = project_root / ".titan"
+
+        # Add .titan directory to sys.path to enable absolute imports
+        titan_dir_str = str(self._titan_dir)
+        if titan_dir_str not in sys.path:
+            sys.path.insert(0, titan_dir_str)
+
+    def get_step(self, step_name: str) -> Optional[StepFunction]:
+        """
+        Retrieves a step function by name.
+        Project steps should use absolute imports from .titan/ as the root.
+        """
+        if step_name in self._step_function_cache:
+            return self._step_function_cache[step_name]
+
+        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 or any(part.startswith("__") for part in step_file.parts):
+                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
+                    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 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,23 @@ 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 workflow uses multiple plugins, treat as custom/project workflow
+                if len(real_plugins) > 1:
+                    return "Project"
+                elif len(real_plugins) == 1:
+                    # Single plugin dependency
+                    return real_plugins[0].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/__init__.py

@@ -5,7 +5,7 @@ This module provides the execution engine for composing and running workflows
 using the Atomic Steps Pattern.
 
 Core components:
-- WorkflowResult types (Success, Error, Skip)
+- WorkflowResult types (Success, Error, Skip, Exit)
 - WorkflowContext for dependency injection
 - WorkflowContextBuilder for fluent API
 - WorkflowExecutor for executing YAML workflows (see workflow_executor.py)
@@ -16,9 +16,11 @@ from .results import (
     Success,
     Error,
     Skip,
+    Exit,
     is_success,
     is_error,
     is_skip,
+    is_exit,
 )
 from .context import WorkflowContext
 from .builder import WorkflowContextBuilder
@@ -29,10 +31,12 @@ __all__ = [
     "Success",
     "Error",
     "Skip",
+    "Exit",
     # Helper functions
     "is_success",
     "is_error",
     "is_skip",
+    "is_exit",
     # Context & builder
     "WorkflowContext",
     "WorkflowContextBuilder",

titan_cli/engine/results.py

@@ -68,8 +68,33 @@ class Skip:
     metadata: Optional[dict[str, Any]] = None
 
 
+@dataclass(frozen=True)
+class Exit:
+    """
+    Exit the entire workflow early (not an error).
+
+    Use when the workflow should stop because it's not needed:
+    - No changes to commit
+    - Nothing to do
+    - Preconditions not met
+
+    This exits the ENTIRE workflow, not just the current step.
+
+    Attributes:
+        message: Why the workflow is exiting (required)
+        metadata: Metadata to auto-merge into ctx.data
+
+    Examples:
+        >>> if not has_changes:
+        >>>     return Exit("No changes to commit")
+        >>> return Exit("Already up to date", metadata={"status": "clean"})
+    """
+    message: str
+    metadata: Optional[dict[str, Any]] = None
+
+
 # Type alias for workflow results
-WorkflowResult = Union[Success, Error, Skip]
+WorkflowResult = Union[Success, Error, Skip, Exit]
 
 
 # ============================================================================
@@ -89,3 +114,8 @@ def is_error(result: WorkflowResult) -> bool:
 def is_skip(result: WorkflowResult) -> bool:
     """Check if result is Skip."""
     return isinstance(result, Skip)
+
+
+def is_exit(result: WorkflowResult) -> bool:
+    """Check if result is Exit."""
+    return isinstance(result, Exit)

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.error_text(f"Invalid cli_preference: {cli_preference}. Must be one of {VALID_CLI_PREFERENCES}")
+        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.error_text(msg.AIAssistant.CONTEXT_KEY_REQUIRED)
+        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.dim_text(friendly_msg)
+        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.error_text(msg.AIAssistant.INVALID_PROMPT_TEMPLATE.format(e=e))
+        ctx.textual.end_step("error")
         return Error(msg.AIAssistant.INVALID_PROMPT_TEMPLATE.format(e=e))
     except Exception as e:
+        ctx.textual.error_text(msg.AIAssistant.FAILED_TO_BUILD_PROMPT.format(e=e))
+        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.warning_text(msg.AIAssistant.DECLINED_ASSISTANCE_STOPPED)
+                ctx.textual.end_step("error")
                 return Error(msg.AIAssistant.DECLINED_ASSISTANCE_STOPPED)
+            ctx.textual.dim_text(msg.AIAssistant.DECLINED_ASSISTANCE_SKIPPED)
+            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.warning_text(msg.AIAssistant.NO_ASSISTANT_CLI_FOUND)
+        ctx.textual.end_step("skip")
         return Skip(msg.AIAssistant.NO_ASSISTANT_CLI_FOUND)
 
     if len(available_launchers) == 1:
@@ -125,7 +151,7 @@ def execute_ai_assistant_step(step: WorkflowStepModel, ctx: WorkflowContext) ->
     else:
         # Show available CLIs with numbers
         ctx.textual.text("")  # spacing
-        ctx.textual.text(msg.AIAssistant.SELECT_ASSISTANT_CLI, markup="bold cyan")
+        ctx.textual.bold_primary_text(msg.AIAssistant.SELECT_ASSISTANT_CLI)
 
         cli_options = list(available_launchers.keys())
         for idx, cli_name in enumerate(cli_options, 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.dim_text(msg.AIAssistant.DECLINED_ASSISTANCE_SKIPPED)
+            ctx.textual.end_step("skip")
             return Skip(msg.AIAssistant.DECLINED_ASSISTANCE_SKIPPED)
 
         try:
@@ -143,28 +171,31 @@ def execute_ai_assistant_step(step: WorkflowStepModel, ctx: WorkflowContext) ->
             if 0 <= choice_idx < len(cli_options):
                 cli_to_launch = cli_options[choice_idx]
             else:
-                ctx.textual.text("Invalid option selected", markup="red")
+                ctx.textual.error_text("Invalid option selected")
+                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.error_text("Invalid input - must be a number")
+            ctx.textual.end_step("skip")
             return Skip(msg.AIAssistant.DECLINED_ASSISTANCE_SKIPPED)
 
     # Validate selection
     if cli_to_launch not in available_launchers:
+        ctx.textual.error_text(f"Unknown CLI to launch: {cli_to_launch}")
+        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")
+    ctx.textual.primary_text(msg.AIAssistant.LAUNCHING_ASSISTANT.format(cli_name=cli_name))
 
     # Show prompt preview
     prompt_preview_text = msg.AIAssistant.PROMPT_PREVIEW.format(
         prompt_preview=f"{prompt[:100]}..." if len(prompt) > 100 else prompt
     )
-    ctx.textual.text(prompt_preview_text, markup="dim")
+    ctx.textual.dim_text(prompt_preview_text)
     ctx.textual.text("")  # spacing
 
     project_root = ctx.get("project_root", ".")
@@ -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.success_text(msg.AIAssistant.BACK_IN_TITAN)
 
     if exit_code != 0:
+        ctx.textual.warning_text(msg.AIAssistant.ASSISTANT_EXITED_WITH_CODE.format(cli_name=cli_name, exit_code=exit_code))
+        ctx.textual.end_step("error")
         return Error(msg.AIAssistant.ASSISTANT_EXITED_WITH_CODE.format(cli_name=cli_name, exit_code=exit_code))
 
+    ctx.textual.success_text(msg.AIAssistant.ASSISTANT_EXITED_WITH_CODE.format(cli_name=cli_name, exit_code=exit_code))
+    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

@@ -4,7 +4,7 @@ from typing import Any, Dict, Optional
 from titan_cli.core.workflows import ParsedWorkflow
 from titan_cli.core.workflows.workflow_exceptions import WorkflowExecutionError
 from titan_cli.engine.context import WorkflowContext
-from titan_cli.engine.results import WorkflowResult, Success, Error, is_error, is_skip
+from titan_cli.engine.results import WorkflowResult, Success, Error, is_error, is_skip, is_exit
 from titan_cli.core.workflows.workflow_registry import WorkflowRegistry
 from titan_cli.core.plugins.plugin_registry import PluginRegistry
 from titan_cli.core.workflows.models import WorkflowStepModel
@@ -75,7 +75,12 @@ class WorkflowExecutor:
                     step_result = Error(f"An unexpected error occurred in step '{step_name}': {e}", e)
 
                 # Handle step result
-                if is_error(step_result):
+                if is_exit(step_result):
+                    # Exit immediately - workflow is done (not an error)
+                    if step_result.metadata:
+                        ctx.data.update(step_result.metadata)
+                    return Success(step_result.message, step_result.metadata)
+                elif is_error(step_result):
                     if step_config.on_error == "fail":
                         return Error(f"Workflow failed at step '{step_name}'", step_result.exception)
                     # else: on_error == "continue" - continue to next step
@@ -128,6 +133,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 +170,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

@@ -567,6 +567,22 @@ class PluginConfigWizardScreen(BaseScreen):
             # Save secrets
             project_name = self.config.get_project_name()
             for secret_key, secret_value in secrets_to_save.items():
+                # Clean up old secrets for this key to avoid conflicts
+                # This prevents accumulation of stale tokens from previous configurations
+                if self.plugin_name == "jira" and "api_token" in secret_key:
+                    # Delete all possible old JIRA token variants
+                    old_keys = [
+                        secret_key,  # Generic: jira_api_token
+                        f"{project_name}_{secret_key}" if project_name else None,  # Project-specific
+                    ]
+                    for old_key in old_keys:
+                        if old_key:
+                            try:
+                                self.config.secrets.delete(old_key, scope="user")
+                            except Exception:
+                                pass  # Ignore errors if key doesn't exist
+
+                # Save the new secret
                 keychain_key = f"{project_name}_{secret_key}" if project_name else secret_key
                 self.config.secrets.set(keychain_key, secret_value, scope="user")