fast-agent-mcp 0.3.15__py3-none-any.whl → 0.3.16__py3-none-any.whl

fast_agent/ui/elicitation_form.py

@@ -7,6 +7,7 @@ from typing import Any, Dict, Optional
 from mcp.types import ElicitRequestedSchema
 from prompt_toolkit import Application
 from prompt_toolkit.buffer import Buffer
+from prompt_toolkit.filters import Condition
 from prompt_toolkit.formatted_text import FormattedText
 from prompt_toolkit.key_binding import KeyBindings
 from prompt_toolkit.key_binding.bindings.focus import focus_next, focus_previous
@@ -25,6 +26,8 @@ from pydantic import ValidationError as PydanticValidationError
 
 from fast_agent.ui.elicitation_style import ELICITATION_STYLE
 
+text_navigation_mode = False
+
 
 class SimpleNumberValidator(Validator):
     """Simple number validator with real-time feedback."""
@@ -68,7 +71,7 @@ class SimpleStringValidator(Validator):
         self,
         min_length: Optional[int] = None,
         max_length: Optional[int] = None,
-        pattern: Optional[str] = None
+        pattern: Optional[str] = None,
     ):
         self.min_length = min_length
         self.max_length = max_length
@@ -314,6 +317,10 @@ class ElicitationForm:
             ]
         )
 
+        # Use field navigation mode as default
+        global text_navigation_mode
+        text_navigation_mode = False
+
         # Key bindings
         kb = KeyBindings()
 
@@ -325,31 +332,49 @@ class ElicitationForm:
         def focus_previous_with_refresh(event):
             focus_previous(event)
 
+        # Toggle between text navigation mode and field navigation mode
+        @kb.add("c-t")
+        def toggle_text_navigation_mode(event):
+            global text_navigation_mode
+            text_navigation_mode = not text_navigation_mode
+            event.app.invalidate()  # Force redraw the app to update toolbar
+
         # Arrow key navigation - let radio lists handle up/down first
-        @kb.add("down")
+        @kb.add("down", filter=Condition(lambda: not text_navigation_mode))
         def focus_next_arrow(event):
             focus_next(event)
 
-        @kb.add("up")
+        @kb.add("up", filter=Condition(lambda: not text_navigation_mode))
         def focus_previous_arrow(event):
             focus_previous(event)
 
-        @kb.add("right", eager=True)
+        @kb.add("right", eager=True, filter=Condition(lambda: not text_navigation_mode))
         def focus_next_right(event):
             focus_next(event)
 
-        @kb.add("left", eager=True)
+        @kb.add("left", eager=True, filter=Condition(lambda: not text_navigation_mode))
         def focus_previous_left(event):
             focus_previous(event)
 
-        # Enter always submits
-        @kb.add("c-m")
-        def submit(event):
+        # Enter submits in field navigation mode
+        @kb.add("c-m", filter=Condition(lambda: not text_navigation_mode))
+        def submit_enter(event):
             self._accept()
 
-        # Ctrl+J inserts newlines
-        @kb.add("c-j")
-        def insert_newline(event):
+        # Ctrl+J inserts newlines in field navigation mode
+        @kb.add("c-j", filter=Condition(lambda: not text_navigation_mode))
+        def insert_newline_cj(event):
+            # Insert a newline at the cursor position
+            event.current_buffer.insert_text("\n")
+            # Mark this field as multiline when user adds a newline
+            for field_name, widget in self.field_widgets.items():
+                if isinstance(widget, Buffer) and widget == event.current_buffer:
+                    self.multiline_fields.add(field_name)
+                    break
+
+        # Enter inserts new lines in text navigation mode
+        @kb.add("c-m", filter=Condition(lambda: text_navigation_mode))
+        def insert_newline_enter(event):
             # Insert a newline at the cursor position
             event.current_buffer.insert_text("\n")
             # Mark this field as multiline when user adds a newline
@@ -358,6 +383,11 @@ class ElicitationForm:
                     self.multiline_fields.add(field_name)
                     break
 
+        # deactivate ctrl+j in text navigation mode
+        @kb.add("c-j", filter=Condition(lambda: text_navigation_mode))
+        def _(event):
+            pass
+
         # ESC should ALWAYS cancel immediately, no matter what
         @kb.add("escape", eager=True, is_global=True)
         def cancel(event):
@@ -369,18 +399,40 @@ class ElicitationForm:
             if hasattr(self, "_toolbar_hidden") and self._toolbar_hidden:
                 return FormattedText([])
 
-            return FormattedText(
-                [
-                    (
-                        "class:bottom-toolbar.text",
-                        " <TAB>/↑↓→← navigate. <ENTER> submit. <Ctrl+J> insert new line. <ESC> cancel. ",
-                    ),
-                    (
-                        "class:bottom-toolbar.text",
-                        "<Cancel All> Auto-Cancel further elicitations from this Server.",
-                    ),
-                ]
-            )
+            mode_label = "TEXT MODE" if text_navigation_mode else "FIELD MODE"
+            mode_color = "ansired" if text_navigation_mode else "ansigreen"
+
+            arrow_up = "↑"
+            arrow_down = "↓"
+            arrow_left = "←"
+            arrow_right = "→"
+
+            if text_navigation_mode:
+                actions_line = (
+                    "  <ESC> cancel. <Cancel All> Auto-Cancel further elicitations from this Server."
+                )
+                navigation_tail = (
+                    " | <CTRL+T> toggle text mode. <TAB> navigate. <ENTER> insert new line."
+                )
+            else:
+                actions_line = (
+                    "  <ENTER> submit. <ESC> cancel. <Cancel All> Auto-Cancel further elicitations "
+                    "from this Server."
+                )
+                navigation_tail = (
+                    " | <CTRL+T> toggle text mode. "
+                    f"<TAB>/{arrow_up}{arrow_down}{arrow_right}{arrow_left} navigate. "
+                    "<Ctrl+J> insert new line."
+                )
+
+            formatted_segments = [
+                ("class:bottom-toolbar.text", actions_line),
+                ("", "\n"),
+                ("class:bottom-toolbar.text", " | "),
+                (f"fg:{mode_color} bg:ansiblack", f" {mode_label} "),
+                ("class:bottom-toolbar.text", navigation_tail),
+            ]
+            return FormattedText(formatted_segments)
 
         # Store toolbar function reference for later control
         self._get_toolbar = get_toolbar
@@ -388,7 +440,7 @@ class ElicitationForm:
 
         # Create toolbar window that we can reference later
         self._toolbar_window = Window(
-            FormattedTextControl(get_toolbar), height=1, style="class:bottom-toolbar"
+            FormattedTextControl(get_toolbar), height=2, style="class:bottom-toolbar"
         )
 
         # Add toolbar to the layout

fast_agent/ui/elicitation_style.py

@@ -53,7 +53,7 @@ ELICITATION_STYLE = Style.from_dict(
         "completion-menu.meta.completion": "bg:ansiblack fg:ansiblue",
         "completion-menu.meta.completion.current": "bg:ansibrightblack fg:ansiblue",
         # Toolbar - matching enhanced_prompt.py exactly
-        "bottom-toolbar": "fg:ansiblack bg:ansigray",
-        "bottom-toolbar.text": "fg:ansiblack bg:ansigray",
+        "bottom-toolbar": "fg:#ansiblack bg:#ansigray",
+        "bottom-toolbar.text": "fg:#ansiblack bg:#ansigray",
     }
 )

fast_agent/ui/enhanced_prompt.py

@@ -121,6 +121,14 @@ async def _display_agent_info_helper(agent_name: str, agent_provider: "AgentApp
         prompts_dict = await agent.list_prompts()
         prompt_count = sum(len(prompts) for prompts in prompts_dict.values()) if prompts_dict else 0
 
+        skill_count = 0
+        skill_manifests = getattr(agent, "_skill_manifests", None)
+        if skill_manifests:
+            try:
+                skill_count = len(list(skill_manifests))
+            except TypeError:
+                skill_count = 0
+
         # Handle different agent types
         if agent.agent_type == AgentType.PARALLEL:
             # Count child agents for parallel agents
@@ -149,36 +157,38 @@ async def _display_agent_info_helper(agent_name: str, agent_provider: "AgentApp
                     f"[dim]Agent [/dim][blue]{agent_name}[/blue][dim]:[/dim] {child_count:,}[dim] {child_word}[/dim]"
                 )
         else:
-            # For regular agents, only display if they have MCP servers attached
-            if server_count > 0:
-                # Build display parts in order: tools, prompts, resources (omit if count is 0)
-                display_parts = []
+            content_parts = []
 
+            if server_count > 0:
+                sub_parts = []
                 if tool_count > 0:
                     tool_word = "tool" if tool_count == 1 else "tools"
-                    display_parts.append(f"{tool_count:,}[dim] {tool_word}[/dim]")
-
+                    sub_parts.append(f"{tool_count:,}[dim] {tool_word}[/dim]")
                 if prompt_count > 0:
                     prompt_word = "prompt" if prompt_count == 1 else "prompts"
-                    display_parts.append(f"{prompt_count:,}[dim] {prompt_word}[/dim]")
-
+                    sub_parts.append(f"{prompt_count:,}[dim] {prompt_word}[/dim]")
                 if resource_count > 0:
                     resource_word = "resource" if resource_count == 1 else "resources"
-                    display_parts.append(f"{resource_count:,}[dim] {resource_word}[/dim]")
+                    sub_parts.append(f"{resource_count:,}[dim] {resource_word}[/dim]")
 
-                # Always show server count
                 server_word = "Server" if server_count == 1 else "Servers"
                 server_text = f"{server_count:,}[dim] MCP {server_word}[/dim]"
-
-                if display_parts:
-                    content = (
-                        f"{server_text}[dim], [/dim]"
-                        + "[dim], [/dim]".join(display_parts)
-                        + "[dim] available[/dim]"
+                if sub_parts:
+                    server_text = (
+                        f"{server_text}[dim] ([/dim]"
+                        + "[dim], [/dim]".join(sub_parts)
+                        + "[dim])[/dim]"
                     )
-                else:
-                    content = f"{server_text}[dim] available[/dim]"
+                content_parts.append(server_text)
 
+            if skill_count > 0:
+                skill_word = "skill" if skill_count == 1 else "skills"
+                content_parts.append(
+                    f"{skill_count:,}[dim] {skill_word}[/dim][dim] available[/dim]"
+                )
+
+            if content_parts:
+                content = "[dim]. [/dim]".join(content_parts)
                 rich_print(f"[dim]Agent [/dim][blue]{agent_name}[/blue][dim]:[/dim] {content}")
         #               await _render_mcp_status(agent)
 
@@ -351,9 +361,11 @@ class AgentCompleter(Completer):
         self.commands = {
             "mcp": "Show MCP server status",
             "history": "Show conversation history overview (optionally another agent)",
-            "tools": "List available MCP tools",
+            "tools": "List available MCP Tools",
+            "skills": "List available Agent Skills",
             "prompt": "List and choose MCP prompts, or apply specific prompt (/prompt <name>)",
             "clear": "Clear history",
+            "clear last": "Remove the most recent message from history",
             "agents": "List available agents",
             "system": "Show the current system prompt",
             "usage": "Show current usage statistics",
@@ -854,8 +866,34 @@ async def get_enhanced_input(
     )
     session.app.key_bindings = bindings
 
+    shell_agent = None
+    shell_enabled = False
+    shell_access_modes: tuple[str, ...] = ()
+    shell_name: str | None = None
+    if agent_provider:
+        try:
+            shell_agent = agent_provider._agent(agent_name)
+        except Exception:
+            shell_agent = None
+
+    if shell_agent:
+        shell_enabled = bool(getattr(shell_agent, "_shell_runtime_enabled", False))
+        modes_attr = getattr(shell_agent, "_shell_access_modes", ())
+        if isinstance(modes_attr, (list, tuple)):
+            shell_access_modes = tuple(str(mode) for mode in modes_attr)
+        elif modes_attr:
+            shell_access_modes = (str(modes_attr),)
+
+        # Get the detected shell name from the runtime
+        if shell_enabled:
+            shell_runtime = getattr(shell_agent, "_shell_runtime", None)
+            if shell_runtime:
+                runtime_info = shell_runtime.runtime_info()
+                shell_name = runtime_info.get("name")
+
     # Create formatted prompt text
-    prompt_text = f"<ansibrightblue>{agent_name}</ansibrightblue> ❯ "
+    arrow_segment = "<ansibrightyellow>❯</ansibrightyellow>" if shell_enabled else "❯"
+    prompt_text = f"<ansibrightblue>{agent_name}</ansibrightblue> {arrow_segment} "
 
     # Add default value display if requested
     if show_default and default and default != "STOP":
@@ -887,8 +925,10 @@ async def get_enhanced_input(
                 # Get logger settings from the agent's context (not agent_provider)
                 logger_settings = None
                 try:
-                    agent = agent_provider._agent(agent_name)
-                    agent_context = agent._context or agent.context
+                    active_agent = shell_agent
+                    if active_agent is None:
+                        active_agent = agent_provider._agent(agent_name)
+                    agent_context = active_agent._context or active_agent.context
                     logger_settings = agent_context.config.logger
                 except Exception:
                     # If we can't get the agent or its context, logger_settings stays None
@@ -922,6 +962,11 @@ async def get_enhanced_input(
                                     f"[dim]Experimental: Streaming Enabled - {streaming_mode} mode[/dim]"
                                 )
 
+        if shell_enabled:
+            modes_display = ", ".join(shell_access_modes or ("direct",))
+            shell_display = f"{modes_display}, {shell_name}" if shell_name else modes_display
+            rich_print(f"[yellow]Shell Access ({shell_display})[/yellow]")
+
         rich_print()
         help_message_shown = True
 
@@ -953,9 +998,16 @@ async def get_enhanced_input(
             elif cmd == "clear":
                 target_agent = None
                 if len(cmd_parts) > 1:
-                    candidate = cmd_parts[1].strip()
-                    if candidate:
-                        target_agent = candidate
+                    remainder = cmd_parts[1].strip()
+                    if remainder:
+                        tokens = remainder.split(maxsplit=1)
+                        if tokens and tokens[0].lower() == "last":
+                            if len(tokens) > 1:
+                                candidate = tokens[1].strip()
+                                if candidate:
+                                    target_agent = candidate
+                            return {"clear_last": {"agent": target_agent}}
+                        target_agent = remainder
                 return {"clear_history": {"agent": target_agent}}
             elif cmd == "markdown":
                 return "MARKDOWN"
@@ -984,6 +1036,8 @@ async def get_enhanced_input(
             elif cmd == "tools":
                 # Return a dictionary with list_tools action
                 return {"list_tools": True}
+            elif cmd == "skills":
+                return {"list_skills": True}
             elif cmd == "exit":
                 return "EXIT"
             elif cmd.lower() == "stop":
@@ -1147,8 +1201,10 @@ async def handle_special_commands(
         rich_print("  /system        - Show the current system prompt")
         rich_print("  /prompt <name> - Apply a specific prompt by name")
         rich_print("  /usage         - Show current usage statistics")
+        rich_print("  /skills        - List local skills for the active agent")
         rich_print("  /history [agent_name] - Show chat history overview")
         rich_print("  /clear [agent_name]   - Clear conversation history (keeps templates)")
+        rich_print("  /clear last [agent_name] - Remove the most recent message from history")
         rich_print("  /markdown      - Show last assistant message without markdown formatting")
         rich_print("  /mcpstatus     - Show MCP server status summary for the active agent")
         rich_print("  /save_history <filename> - Save current chat history to a file")

fast_agent/ui/history_display.py

@@ -35,6 +35,7 @@ class Colours:
     USER = "blue"
     ASSISTANT = "green"
     TOOL = "magenta"
+    TOOL_ERROR = "red"
     HEADER = USER
     TIMELINE_EMPTY = "dim default"
     CONTEXT_SAFE = "green"
@@ -249,6 +250,7 @@ def _build_history_rows(history: Sequence[PromptMessageExtended]) -> list[dict]:
         result_rows: list[dict] = []
         tool_result_total_chars = 0
         tool_result_has_non_text = False
+        tool_result_has_error = False
 
         if tool_calls:
             names: list[str] = []
@@ -273,6 +275,8 @@ def _build_history_rows(history: Sequence[PromptMessageExtended]) -> list[dict]:
                 tool_result_total_chars += result_chars
                 tool_result_has_non_text = tool_result_has_non_text or result_non_text
                 detail = _format_tool_detail("result→", [tool_name])
+                is_error = getattr(result, "isError", False)
+                tool_result_has_error = tool_result_has_error or is_error
                 result_rows.append(
                     {
                         "role": "tool",
@@ -284,6 +288,7 @@ def _build_history_rows(history: Sequence[PromptMessageExtended]) -> list[dict]:
                         "has_tool_request": False,
                         "hide_summary": False,
                         "include_in_timeline": False,
+                        "is_error": is_error,
                     }
                 )
             if role == "user":
@@ -308,6 +313,7 @@ def _build_history_rows(history: Sequence[PromptMessageExtended]) -> list[dict]:
         if timeline_role == "tool" and tool_result_total_chars > 0:
             row_chars = tool_result_total_chars
         row_non_text = row_non_text or tool_result_has_non_text
+        row_is_error = tool_result_has_error
 
         rows.append(
             {
@@ -320,6 +326,7 @@ def _build_history_rows(history: Sequence[PromptMessageExtended]) -> list[dict]:
                 "has_tool_request": has_tool_request,
                 "hide_summary": hide_in_summary,
                 "include_in_timeline": include_in_timeline,
+                "is_error": row_is_error,
             }
         )
         rows.extend(result_rows)
@@ -333,12 +340,23 @@ def _aggregate_timeline_entries(rows: Sequence[dict]) -> list[dict]:
             "role": row.get("timeline_role", row["role"]),
             "chars": row["chars"],
             "non_text": row["non_text"],
+            "is_error": row.get("is_error", False),
         }
         for row in rows
         if row.get("include_in_timeline", True)
     ]
 
 
+def _get_role_color(role: str, *, is_error: bool = False) -> str:
+    """Get the display color for a role, accounting for error states."""
+    color_map = {"user": Colours.USER, "assistant": Colours.ASSISTANT, "tool": Colours.TOOL}
+
+    if role == "tool" and is_error:
+        return Colours.TOOL_ERROR
+
+    return color_map.get(role, "white")
+
+
 def _shade_block(chars: int, *, non_text: bool, color: str) -> Text:
     if non_text:
         return Text(NON_TEXT_MARKER, style=f"bold {color}")
@@ -356,12 +374,10 @@ def _shade_block(chars: int, *, non_text: bool, color: str) -> Text:
 
 
 def _build_history_bar(entries: Sequence[dict], width: int = TIMELINE_WIDTH) -> tuple[Text, Text]:
-    color_map = {"user": Colours.USER, "assistant": Colours.ASSISTANT, "tool": Colours.TOOL}
-
     recent = list(entries[-width:])
     bar = Text(" history |", style="dim")
     for entry in recent:
-        color = color_map.get(entry["role"], "ansiwhite")
+        color = _get_role_color(entry["role"], is_error=entry.get("is_error", False))
         bar.append_text(
             _shade_block(entry["chars"], non_text=entry.get("non_text", False), color=color)
         )
@@ -507,7 +523,6 @@ def display_history_overview(
     start_index = len(summary_candidates) - len(summary_rows) + 1
 
     role_arrows = {"user": "▶", "assistant": "◀", "tool": "▶"}
-    role_styles = {"user": Colours.USER, "assistant": Colours.ASSISTANT, "tool": Colours.TOOL}
     role_labels = {"user": "user", "assistant": "assistant", "tool": "tool result"}
 
     try:
@@ -517,7 +532,7 @@ def display_history_overview(
 
     for offset, row in enumerate(summary_rows):
         role = row["role"]
-        color = role_styles.get(role, "white")
+        color = _get_role_color(role, is_error=row.get("is_error", False))
         arrow = role_arrows.get(role, "▶")
         label = role_labels.get(role, role)
         if role == "assistant" and row.get("has_tool_request"):

fast_agent/ui/interactive_prompt.py

@@ -14,6 +14,7 @@ Usage:
     )
 """
 
+from pathlib import Path
 from typing import TYPE_CHECKING, Any, Awaitable, Callable, Dict, List, Optional, Union, cast
 
 if TYPE_CHECKING:
@@ -169,6 +170,9 @@ class InteractivePrompt:
                         # Handle tools list display
                         await self._list_tools(prompt_provider, agent)
                         continue
+                    elif "list_skills" in command_dict:
+                        await self._list_skills(prompt_provider, agent)
+                        continue
                     elif "show_usage" in command_dict:
                         # Handle usage display
                         await self._show_usage(prompt_provider, agent)
@@ -189,6 +193,41 @@ class InteractivePrompt:
                         usage = getattr(agent_obj, "usage_accumulator", None)
                         display_history_overview(target_agent, history, usage)
                         continue
+                    elif "clear_last" in command_dict:
+                        clear_info = command_dict.get("clear_last")
+                        clear_agent = (
+                            clear_info.get("agent") if isinstance(clear_info, dict) else None
+                        )
+                        target_agent = clear_agent or agent
+                        try:
+                            agent_obj = prompt_provider._agent(target_agent)
+                        except Exception:
+                            rich_print(f"[red]Unable to load agent '{target_agent}'[/red]")
+                            continue
+
+                        removed_message = None
+                        pop_callable = getattr(agent_obj, "pop_last_message", None)
+                        if callable(pop_callable):
+                            removed_message = pop_callable()
+                        else:
+                            history = getattr(agent_obj, "message_history", [])
+                            if history:
+                                try:
+                                    removed_message = history.pop()
+                                except Exception:
+                                    removed_message = None
+
+                        if removed_message:
+                            role = getattr(removed_message, "role", "message")
+                            role_display = role.capitalize() if isinstance(role, str) else "Message"
+                            rich_print(
+                                f"[green]Removed last {role_display} for agent '{target_agent}'.[/green]"
+                            )
+                        else:
+                            rich_print(
+                                f"[yellow]No messages to remove for agent '{target_agent}'.[/yellow]"
+                            )
+                        continue
                     elif "clear_history" in command_dict:
                         clear_info = command_dict.get("clear_history")
                         clear_agent = (
@@ -857,19 +896,21 @@ class InteractivePrompt:
             rich_print()
 
             # Display tools using clean compact format
-            for i, tool in enumerate(tools_result.tools, 1):
+            index = 1
+            for tool in tools_result.tools:
                 # Main line: [ 1] tool_name Title
                 from rich.text import Text
 
+                meta = getattr(tool, "meta", {}) or {}
+
                 tool_line = Text()
-                tool_line.append(f"[{i:2}] ", style="dim cyan")
+                tool_line.append(f"[{index:2}] ", style="dim cyan")
                 tool_line.append(tool.name, style="bright_blue bold")
 
                 # Add title if available
                 if tool.title and tool.title.strip():
                     tool_line.append(f" {tool.title}", style="default")
 
-                meta = getattr(tool, "meta", {}) or {}
                 if meta.get("openai/skybridgeEnabled"):
                     tool_line.append(" (skybridge)", style="cyan")
 
@@ -932,13 +973,77 @@ class InteractivePrompt:
                         rich_print(f"     [dim magenta]template:[/dim magenta] {template}")
 
                 rich_print()  # Space between tools
+                index += 1
 
+            if index == 1:
+                rich_print("[yellow]No MCP tools available for this agent[/yellow]")
         except Exception as e:
             import traceback
 
             rich_print(f"[red]Error listing tools: {e}[/red]")
             rich_print(f"[dim]{traceback.format_exc()}[/dim]")
 
+    async def _list_skills(self, prompt_provider: "AgentApp", agent_name: str) -> None:
+        """List available local skills for an agent."""
+
+        try:
+            assert hasattr(prompt_provider, "_agent"), (
+                "Interactive prompt expects an AgentApp with _agent()"
+            )
+            agent = prompt_provider._agent(agent_name)
+
+            rich_print(f"\n[bold]Skills for agent [cyan]{agent_name}[/cyan]:[/bold]")
+
+            skill_manifests = getattr(agent, "_skill_manifests", None)
+            manifests = list(skill_manifests) if skill_manifests else []
+
+            if not manifests:
+                rich_print("[yellow]No skills available for this agent[/yellow]")
+                return
+
+            rich_print()
+
+            for index, manifest in enumerate(manifests, 1):
+                from rich.text import Text
+
+                name = getattr(manifest, "name", "")
+                description = getattr(manifest, "description", "")
+                path = Path(getattr(manifest, "path", Path()))
+
+                tool_line = Text()
+                tool_line.append(f"[{index:2}] ", style="dim cyan")
+                tool_line.append(name, style="bright_blue bold")
+                rich_print(tool_line)
+
+                if description:
+                    import textwrap
+
+                    wrapped_lines = textwrap.wrap(
+                        description.strip(), width=72, subsequent_indent="     "
+                    )
+                    for line in wrapped_lines:
+                        if line.startswith("     "):
+                            rich_print(f"     [white]{line[5:]}[/white]")
+                        else:
+                            rich_print(f"     [white]{line}[/white]")
+
+                source_path = path if path else Path(".")
+                if source_path.is_file():
+                    source_path = source_path.parent
+                try:
+                    display_path = source_path.relative_to(Path.cwd())
+                except ValueError:
+                    display_path = source_path
+
+                rich_print(f"     [dim green]source:[/dim green] {display_path}")
+                rich_print()
+
+        except Exception as exc:  # noqa: BLE001
+            import traceback
+
+            rich_print(f"[red]Error listing skills: {exc}[/red]")
+            rich_print(f"[dim]{traceback.format_exc()}[/dim]")
+
     async def _show_usage(self, prompt_provider: "AgentApp", agent_name: str) -> None:
         """
         Show usage statistics for the current agent(s) in a colorful table format.

fast_agent/ui/markdown_truncator.py

@@ -876,7 +876,7 @@ class MarkdownTruncator:
             return truncated_text
 
         # Find where the truncated text starts in the original
-        truncation_pos = original_text.find(truncated_text)
+        truncation_pos = original_text.rfind(truncated_text)
         if truncation_pos == -1:
             # Can't find it, return as-is
             return truncated_text