bone-agent 1.3.2 → 1.4.0

package/src/ui/commands.py

@@ -1,12 +1,14 @@
 """Command routing and help display."""
 
+import os
 import re
+import subprocess
 from dataclasses import dataclass
 from typing import Optional
 from llm import config
 
 from core.config_manager import ConfigManager as ConfigManagerClass
-from ui.displays import show_help_table, show_cron_help_table
+from ui.displays import show_help_table, show_cron_help_table, show_skills_help_table
 from ui.banner import display_startup_banner
 from core.agentic import SubAgentPanel
 from ui.setting_selector import SettingSelector, SettingCategory, SettingOption
@@ -155,6 +157,9 @@ def _cron_remove(console, sub_args, cron_config, notify_scheduler):
     if not job_id:
         console.print("[red]Usage: /cron remove <id>[/red]")
         return CommandResult(status="handled")
+    if job_id == "dream":
+        console.print("[red]The 'dream' job is managed by DREAM_SETTINGS.enabled in config.yaml and cannot be removed.[/red]")
+        return CommandResult(status="handled")
     if cron_config.remove_job(job_id):
         notify_scheduler()
         console.print(f"[green]Removed cron job '{job_id}'[/green]")
@@ -171,6 +176,9 @@ def _cron_toggle(console, sub_args, cron_config, notify_scheduler, enable):
     if not job_id:
         console.print(f"[red]Usage: /cron {verb} <id>[/red]")
         return CommandResult(status="handled")
+    if not enable and job_id == "dream":
+        console.print("[red]The 'dream' job is managed by DREAM_SETTINGS.enabled in config.yaml and cannot be disabled via /cron.[/red]")
+        return CommandResult(status="handled")
     if job_id in cron_config.jobs:
         cron_config.update_job(job_id, enabled=enable)
         notify_scheduler()
@@ -381,6 +389,12 @@ def _handle_config(chat_manager, console, debug_mode_container, args, cron_sched
                 {"value": "danger", "text": "DANGER"},
             ],
         ),
+        SettingOption(
+            key="memory_enabled", text="Memory",
+            value=config.MEMORY_SETTINGS.get("enabled", True),
+            input_type="boolean",
+            on_text="ON", off_text="OFF",
+        ),
     ]
 
     # Build status bar settings
@@ -480,6 +494,10 @@ def _handle_config(chat_manager, console, debug_mode_container, args, cron_sched
                 console.print("[bold red on default]  Dangerous git commands are still blocked.[/bold red on default]")
                 console.print("[bold yellow on default]  Use at your own risk![/bold yellow on default]")
                 console.print()
+        elif key == "memory_enabled":
+            config.update_memory_settings({"enabled": value})
+            state = "enabled" if value else "disabled"
+            change_lines.append(f"  Memory: {state}")
         elif key == "compact_trigger_tokens":
             context_settings.compact_trigger_tokens = int(value)
             change_lines.append(f"  Compaction Threshold: {value:,} tokens")
@@ -531,6 +549,17 @@ def _handle_config(chat_manager, console, debug_mode_container, args, cron_sched
         except Exception as e:
             console.print(f"[red]Failed to save status bar settings: {e}[/red]")
 
+    # Persist memory setting to config
+    if "memory_enabled" in changes:
+        try:
+            cfg_data = config_manager.load(force_reload=True)
+            if "MEMORY_SETTINGS" not in cfg_data:
+                cfg_data["MEMORY_SETTINGS"] = {}
+            cfg_data["MEMORY_SETTINGS"]["enabled"] = changes["memory_enabled"]
+            config_manager.save(cfg_data)
+        except Exception as e:
+            console.print(f"[red]Failed to save memory settings: {e}[/red]")
+
     # Display summary
     console.print(f"[green]Settings updated:[/green]")
     for line in change_lines:
@@ -561,12 +590,16 @@ def _handle_clear(chat_manager, console, debug_mode_container, args, cron_schedu
     conv_cache_read = chat_manager.token_tracker.conv_cache_read_tokens
     conv_cache_creation = chat_manager.token_tracker.conv_cache_creation_tokens
     if conv_cache_read > 0 or conv_cache_creation > 0:
-        cache_hit_pct = (
+        total_cached = conv_cache_read + conv_cache_creation
+        cache_activity_read_pct = (
+            conv_cache_read / total_cached * 100
+        ) if total_cached > 0 else 0
+        cache_coverage_pct = (
             conv_cache_read / conv_in * 100
         ) if conv_in > 0 else 0
         console.print(f"  Cache read:   {conv_cache_read:,} tokens")
         console.print(f"  Cache write:  {conv_cache_creation:,} tokens")
-        console.print(f"  ({cache_hit_pct:.0f}% of input served from cache)")
+        console.print(f"  ({cache_coverage_pct:.0f}% input cached, {cache_activity_read_pct:.0f}% cache reads)")
 
     # Display cost — combined actual + estimated, with config-based fallback
     tracker_conv = chat_manager.token_tracker
@@ -635,11 +668,12 @@ def _open_provider_editor(chat_manager, console, provider):
             min_val=0.0, step=0.01,
         ))
 
-    category = SettingCategory(title=f"{provider.capitalize()} Settings", settings=settings)
+    provider_label = config.get_provider_display_name(provider)
+    category = SettingCategory(title=f"{provider_label} Settings", settings=settings)
 
     selector = SettingSelector(
         categories=[category],
-        title=f"Configure {provider.capitalize()}",
+        title=f"Configure {provider_label}",
     )
 
     changes = selector.run()
@@ -712,7 +746,8 @@ def _handle_provider(chat_manager, console, debug_mode_container, args, cron_sch
         # Validate provider name
         if provider not in config.get_providers():
             console.print(f"[red]Error: Unknown provider '{provider}'[/red]")
-            console.print(f"[dim]Available providers: {', '.join(config.get_providers())}[/dim]")
+            available = ', '.join(config.get_provider_display_name(prov) for prov in config.get_providers())
+            console.print(f"[dim]Available providers: {available}[/dim]")
             return CommandResult(status="handled")
 
         # Switch directly to the named provider
@@ -726,7 +761,7 @@ def _handle_provider(chat_manager, console, debug_mode_container, args, cron_sch
 
         cfg = config.get_provider_config(provider)
         model = cfg.get('model') or cfg.get('api_model') or ''
-        label = f"{provider.capitalize()}"
+        label = config.get_provider_display_name(provider)
         if model:
             label += f" ({model})"
         console.print(f"[green]Switched to {label}[/green]")
@@ -742,7 +777,7 @@ def _handle_provider(chat_manager, console, debug_mode_container, args, cron_sch
         for prov in config.get_providers():
             cfg = config.get_provider_config(prov)
             model = cfg.get('model') or cfg.get('api_model') or ''
-            entry = {"value": prov, "text": prov.capitalize()}
+            entry = {"value": prov, "text": config.get_provider_display_name(prov)}
             if model:
                 entry["description"] = model[:40]
             provider_options.append(entry)
@@ -1062,17 +1097,38 @@ def _handle_usage(chat_manager, console, debug_mode_container, args, cron_schedu
     console.print(f"  Output tokens: {tracker.total_completion_tokens:,}")
     console.print(f"  Total tokens:  {tracker.total_tokens:,}")
 
-    # Display cache token breakdown (if any cache tokens were recorded)
-    has_cache = tracker.total_cache_read_tokens > 0 or tracker.total_cache_creation_tokens > 0
-    if has_cache:
-        cache_hit_pct = (
+    # Display cache token breakdown when cache tokens were recorded.
+    # Codex can report an explicit 0 cached_tokens value, which is still useful
+    # confirmation that prompt-cache usage data is flowing through.
+    show_cache = (
+        tracker.total_cache_read_tokens > 0
+        or tracker.total_cache_creation_tokens > 0
+        or current_provider == "codex"
+    )
+    if show_cache:
+        total_cached = tracker.total_cache_read_tokens + tracker.total_cache_creation_tokens
+        cache_activity_read_pct = (
+            tracker.total_cache_read_tokens
+            / total_cached * 100
+        ) if total_cached > 0 else 0
+        cache_coverage_pct = (
             tracker.total_cache_read_tokens
             / tracker.total_prompt_tokens * 100
         ) if tracker.total_prompt_tokens > 0 else 0
         console.print()
-        console.print(f"[#5F9EA0]Input Cache ({cache_hit_pct:.0f}% hit rate):[/#5F9EA0]")
+        console.print(
+            f"[#5F9EA0]Input Cache ({cache_coverage_pct:.0f}% input cached, "
+            f"{cache_activity_read_pct:.0f}% cache reads):[/#5F9EA0]"
+        )
         console.print(f"  Cache read:   {tracker.total_cache_read_tokens:,} tokens")
         console.print(f"  Cache write:  {tracker.total_cache_creation_tokens:,} tokens")
+        if current_provider == "codex" and total_cached == 0:
+            if tracker.last_cache_metrics_reported is False:
+                keys = ", ".join(tracker.last_usage_keys) if tracker.last_usage_keys else "none"
+                console.print("  [dim]Codex did not report any cache-token fields in the last usage payload.[/dim]")
+                console.print(f"  [dim]Last usage keys: {keys}[/dim]")
+            elif tracker.last_cache_metrics_reported is None:
+                console.print("  [dim]No usage payload has been recorded yet for this Codex session.[/dim]")
     console.print()
     
 
@@ -2153,8 +2209,8 @@ def _handle_obsidian(chat_manager, console, debug_mode_container, args, cron_sch
     return CommandResult(status="handled")
 
 
-def _persist_disabled_tools(console):
-    """Persist current disabled_tools to config file.
+def _persist_tool_visibility(console):
+    """Persist tool and skill visibility state to config file.
 
     Returns True on success, False on failure.
     """
@@ -2163,6 +2219,7 @@ def _persist_disabled_tools(console):
         if "TOOL_SETTINGS" not in cfg_data:
             cfg_data["TOOL_SETTINGS"] = {}
         cfg_data["TOOL_SETTINGS"]["disabled_tools"] = list(tool_settings.disabled_tools)
+        cfg_data["TOOL_SETTINGS"]["hidden_skills"] = list(tool_settings.hidden_skills)
         config_manager.save(cfg_data)
         return True
     except Exception as e:
@@ -2171,18 +2228,23 @@ def _persist_disabled_tools(console):
 
 
 def _handle_tools(chat_manager, console, debug_mode_container, args, cron_scheduler=None):
-    """Handle /tools command — toggle individual tools or groups on/off.
+    """Handle /tools command — manage tool availability and skill discovery visibility.
 
-    No args: Launch interactive SettingSelector with tools grouped by category.
+    No args: Launch interactive SettingSelector with tools/plugins grouped by category
+    and a skills section for discovery visibility.
     Subcommands:
-      list — show all tools with group labels and status
-      enable <name> — enable a single tool
-      disable <name> — disable a single tool
-      enable-group <key> — enable all tools in a group (e.g. file_ops, search, shell)
+      list — show all tools, plugins, and skills with status
+      enable <name> — enable a core tool or plugin
+      disable <name> — disable a core tool or plugin
+      show-skill <name> — make a skill visible in discovery surfaces
+      hide-skill <name> — hide a skill from discovery surfaces
+      enable-group <key> — enable all tools in a group (e.g. file_ops, task_mgmt)
       disable-group <key> — disable all tools in a group
     """
+    from core.skills import iter_skill_summaries, validate_skill_name
     from ui.setting_selector import SettingOption, SettingCategory, SettingSelector
     from tools.helpers.base import ToolRegistry, TOOL_GROUPS
+    from tools.helpers.plugin_manifest import plugin_manifest
 
     # Text subcommands
     if args:
@@ -2190,17 +2252,27 @@ def _handle_tools(chat_manager, console, debug_mode_container, args, cron_schedu
 
         if args_clean.lower() in ("list", "status"):
             all_tools = sorted(ToolRegistry._tools.values(), key=lambda t: t.name)
+            plugin_defs = sorted(plugin_manifest.get_all(), key=lambda t: t.name)
+            skills = sorted(iter_skill_summaries(), key=lambda s: s.name)
             disabled = ToolRegistry.get_disabled()
-            console.print(f"[bold #5F9EA0]Tools: {len(all_tools) - len(disabled)} enabled, {len(disabled)} disabled[/bold #5F9EA0]")
+            hidden_skills = set(tool_settings.hidden_skills)
+            disabled_tools = {t.name for t in all_tools if t.name in disabled}
+            console.print(
+                f"[bold #5F9EA0]Tools: {len(all_tools) - len(disabled_tools)} enabled, {len(disabled_tools)} disabled[/bold #5F9EA0]"
+            )
+            console.print(
+                f"[bold #5F9EA0]User plugins: {sum(1 for p in plugin_defs if p.name not in disabled)} enabled, {sum(1 for p in plugin_defs if p.name in disabled)} disabled[/bold #5F9EA0]"
+            )
+            console.print(
+                f"[bold #5F9EA0]Skills: {len(skills) - len(hidden_skills)} visible, {len(hidden_skills)} hidden[/bold #5F9EA0]"
+            )
             console.print()
 
-            # Build reverse lookup: tool_name -> group_label
             tool_to_group = {}
             for gkey, gdef in TOOL_GROUPS.items():
                 for tname in gdef["tools"]:
                     tool_to_group.setdefault(tname, []).append(gdef["label"])
 
-            # Group tools for display
             current_group = None
             for t in all_tools:
                 groups = tool_to_group.get(t.name, [])
@@ -2212,6 +2284,18 @@ def _handle_tools(chat_manager, console, debug_mode_container, args, cron_schedu
                 status = "[red]off[/red]" if is_off else "[green]on[/green] "
                 console.print(f"    {status} {t.name}")
 
+            console.print()
+            console.print("  [bold]User plugins[/bold]")
+            for plugin in plugin_defs:
+                status = "[red]off[/red]" if plugin.name in disabled else "[green]on[/green] "
+                console.print(f"    {status} {plugin.name}")
+
+            console.print()
+            console.print("  [bold]Skills[/bold]")
+            for skill in skills:
+                status = "[red]hidden[/red]" if skill.name in hidden_skills else "[green]visible[/green]"
+                console.print(f"    {status} {skill.name}")
+
             console.print()
             console.print("[dim]Groups:[/dim] " + ", ".join(
                 f"[bold]{k}[/bold] ({v['label']})" for k, v in TOOL_GROUPS.items()
@@ -2250,17 +2334,17 @@ def _handle_tools(chat_manager, console, debug_mode_container, args, cron_schedu
 
                 # Sync and persist
                 tool_settings.disabled_tools = sorted(ToolRegistry.get_disabled())
-                _persist_disabled_tools(console)
+                _persist_tool_visibility(console)
                 console.print()
                 return CommandResult(status="handled")
 
-            # Single tool operations
+            # Single tool/plugin operations
             if action in ("enable", "disable"):
-                # Match case-insensitively against registered tools
                 all_registered_lower = {t.name.lower(): t.name for t in ToolRegistry._tools.values()}
+                all_registered_lower.update({t.name.lower(): t.name for t in plugin_manifest.get_all()})
                 matched = all_registered_lower.get(target.lower())
                 if not matched:
-                    console.print(f"[red]Unknown tool: {target}[/red]")
+                    console.print(f"[red]Unknown tool or plugin: {target}[/red]")
                     console.print(f"[dim]Run [bold #5F9EA0]/tools list[/bold #5F9EA0] to see all tools.[/dim]")
                     return CommandResult(status="handled")
 
@@ -2274,17 +2358,44 @@ def _handle_tools(chat_manager, console, debug_mode_container, args, cron_schedu
                         tool_settings.disabled_tools.append(matched)
                     console.print(f"[yellow]Disabled: {matched}[/yellow]")
 
-                _persist_disabled_tools(console)
+                _persist_tool_visibility(console)
+                console.print()
+                return CommandResult(status="handled")
+
+            if action in ("show-skill", "hide-skill"):
+                try:
+                    skill_name = validate_skill_name(target)
+                except Exception as e:
+                    console.print(f"[red]{e}[/red]")
+                    return CommandResult(status="handled")
+
+                known_skills = {skill.name for skill in iter_skill_summaries()}
+                if skill_name not in known_skills:
+                    console.print(f"[red]Unknown skill: {skill_name}[/red]")
+                    return CommandResult(status="handled")
+
+                if action == "show-skill":
+                    tool_settings.hidden_skills = [n for n in tool_settings.hidden_skills if n != skill_name]
+                    console.print(f"[green]Skill visible in discovery: {skill_name}[/green]")
+                else:
+                    if skill_name not in tool_settings.hidden_skills:
+                        tool_settings.hidden_skills.append(skill_name)
+                    console.print(f"[yellow]Skill hidden from discovery: {skill_name}[/yellow]")
+
+                tool_settings.hidden_skills = sorted(set(tool_settings.hidden_skills))
+                _persist_tool_visibility(console)
                 console.print()
                 return CommandResult(status="handled")
 
         console.print(f"[red]Unknown subcommand: {args}[/red]")
-        console.print("Usage: [bold #5F9EA0]/tools[/bold #5F9EA0] [list | enable <name> | disable <name> | enable-group <key> | disable-group <key>]")
+        console.print("Usage: [bold #5F9EA0]/tools[/bold #5F9EA0] [list | enable <name> | disable <name> | show-skill <name> | hide-skill <name> | enable-group <key> | disable-group <key>]")
         return CommandResult(status="handled")
 
     # No args — interactive toggle UI, organized by groups
     all_tools_map = {t.name: t for t in ToolRegistry._tools.values()}
+    plugin_tools = {t.name: t for t in plugin_manifest.get_all()}
     disabled = ToolRegistry.get_disabled()
+    hidden_skills = set(tool_settings.hidden_skills)
 
     categories = []
     for gkey, gdef in TOOL_GROUPS.items():
@@ -2324,10 +2435,36 @@ def _handle_tools(chat_manager, console, debug_mode_container, args, cron_schedu
                 input_type="boolean",
                 on_text="ON",
                 off_text="OFF",
-                description=f"Modes: {modes}",
             ))
         categories.append(SettingCategory(title="Other", settings=other_options))
 
+    plugin_options = []
+    for name in sorted(plugin_tools):
+        is_off = name in disabled
+        plugin_options.append(SettingOption(
+            key=name,
+            text=name,
+            value=not is_off,
+            input_type="boolean",
+            on_text="ON",
+            off_text="OFF",
+        ))
+    if plugin_options:
+        categories.append(SettingCategory(title="User plugins", settings=plugin_options))
+
+    skill_options = []
+    for skill in sorted(iter_skill_summaries(), key=lambda s: s.name):
+        skill_options.append(SettingOption(
+            key=f"skill:{skill.name}",
+            text=skill.name,
+            value=skill.name not in hidden_skills,
+            input_type="boolean",
+            on_text="VISIBLE",
+            off_text="HIDDEN",
+        ))
+    if skill_options:
+        categories.append(SettingCategory(title="Skills", settings=skill_options))
+
     selector = SettingSelector(
         categories=categories,
         title="Tool Settings",
@@ -2346,7 +2483,17 @@ def _handle_tools(chat_manager, console, debug_mode_container, args, cron_schedu
     # Apply changes
     newly_disabled = []
     newly_enabled = []
+    newly_hidden_skills = []
+    newly_visible_skills = []
     for name, enabled in changes.items():
+        if name.startswith("skill:"):
+            skill_name = name.split(":", 1)[1]
+            if enabled and skill_name in hidden_skills:
+                newly_visible_skills.append(skill_name)
+            elif not enabled and skill_name not in hidden_skills:
+                newly_hidden_skills.append(skill_name)
+            continue
+
         if not enabled and name not in disabled:
             ToolRegistry.disable(name)
             newly_disabled.append(name)
@@ -2354,10 +2501,13 @@ def _handle_tools(chat_manager, console, debug_mode_container, args, cron_schedu
             ToolRegistry.enable(name)
             newly_enabled.append(name)
 
-    # Sync tool_settings.disabled_tools to be the full current disabled set
     tool_settings.disabled_tools = sorted(ToolRegistry.get_disabled())
+    next_hidden_skills = set(hidden_skills)
+    next_hidden_skills.update(newly_hidden_skills)
+    next_hidden_skills.difference_update(newly_visible_skills)
+    tool_settings.hidden_skills = sorted(next_hidden_skills)
 
-    _persist_disabled_tools(console)
+    _persist_tool_visibility(console)
 
     # Summary
     change_lines = []
@@ -2365,6 +2515,10 @@ def _handle_tools(chat_manager, console, debug_mode_container, args, cron_schedu
         change_lines.append(f"  [yellow]Disabled:[/yellow] {name}")
     for name in newly_enabled:
         change_lines.append(f"  [green]Enabled:[/green] {name}")
+    for name in newly_hidden_skills:
+        change_lines.append(f"  [yellow]Hidden skill:[/yellow] {name}")
+    for name in newly_visible_skills:
+        change_lines.append(f"  [green]Visible skill:[/green] {name}")
 
     if change_lines:
         total_enabled = len(ToolRegistry.get_all())
@@ -2430,9 +2584,258 @@ def _handle_cd(chat_manager, console, debug_mode_container, args, cron_scheduler
     except Exception:
         pass
 
+    # Rebuild system prompt so project root stays current
+    try:
+        chat_manager.update_system_prompt()
+    except Exception:
+        pass
+
     return CommandResult(status="handled")
 
 
+def _handle_prompt(chat_manager, console, debug_mode_container, args, cron_scheduler=None):
+    """Handle /prompt command — show/swap prompt variants."""
+    from utils.settings import prompt_settings
+    from llm.prompts import _variant_available, _list_variants
+
+    cfg_manager = config_manager
+
+    if not args or args.strip() == "list":
+        variants = _list_variants()
+        current = prompt_settings.variant
+        console.print()
+        console.print(f"[bold #5F9EA0]Prompt Variants[/bold #5F9EA0]  (current: [bold]{current}[/bold])")
+        console.print()
+        for v in variants:
+            marker = "[bold green]active[/bold green]" if v == current else ""
+            console.print(f"  [bold]{v}[/bold]  {marker}")
+        console.print()
+        console.print("[dim]Switch with: [bold #5F9EA0]/prompt main[/bold #5F9EA0] or [bold #5F9EA0]/prompt micro[/bold #5F9EA0][/dim]")
+        return CommandResult(status="handled")
+
+    # Single arg: variant name to switch to
+    target = args.strip().lower()
+
+    if not _variant_available(target):
+        variants = _list_variants()
+        console.print(f"[red]Unknown variant: '{target}'[/red]")
+        console.print(f"[dim]Available: {', '.join(variants)}[/dim]")
+        return CommandResult(status="handled")
+
+    # Update settings
+    prompt_settings.variant = target
+
+    # Persist to config
+    try:
+        cfg_data = cfg_manager.load(force_reload=True)
+        if "PROMPT_SETTINGS" not in cfg_data:
+            cfg_data["PROMPT_SETTINGS"] = {}
+        cfg_data["PROMPT_SETTINGS"]["variant"] = target
+        cfg_manager.save(cfg_data)
+    except Exception as e:
+        console.print(f"[red]Failed to save variant to config: {e}[/red]")
+        console.print("[yellow]Variant applied for this session only — it will revert on restart.[/yellow]")
+
+    # Rebuild system prompt in-place (no restart)
+    chat_manager.update_system_prompt(variant=target)
+    console.print(f"[green]Switched to '{target}' variant[/green]")
+    console.print("[dim]System prompt rebuilt in-place.[/dim]")
+
+    return CommandResult(status="handled")
+
+
+def _print_skills_usage(console):
+    show_skills_help_table(console)
+
+
+def _skills_list(console, query=None):
+    from datetime import datetime
+    from core.skills import get_skills_dir, list_skills
+
+    skills = list_skills(query=query)
+    if not skills:
+        console.print("[dim]No skills found.[/dim]")
+        console.print(f"[dim]Directory: {get_skills_dir()}[/dim]")
+        console.print("[dim]Create one with: [bold #5F9EA0]/skills add frontend_design[/bold #5F9EA0][/dim]")
+        return
+
+    table = Table(show_header=True, box=box.SIMPLE_HEAD)
+    table.add_column("Skill", no_wrap=True)
+    table.add_column("Preview")
+    table.add_column("Modified", no_wrap=True)
+    for skill in skills:
+        modified = datetime.fromtimestamp(skill.modified).strftime("%Y-%m-%d %H:%M")
+        table.add_row(f"[bold]{skill.name}[/bold]", skill.preview, modified)
+    console.print(table)
+    console.print("[dim]Load with: [bold #5F9EA0]/skills load <name>[/bold #5F9EA0][/dim]")
+
+
+def _open_skill_editor(console, debug_mode_container, initial_content):
+    from utils.editor import open_editor_for_content
+
+    return open_editor_for_content(
+        console,
+        initial_content=initial_content,
+        debug_mode=debug_mode_container["debug"],
+    )
+
+
+def _write_skill_from_editor(console, debug_mode_container, name, initial_content, *, overwrite, verb):
+    from core.skills import write_skill
+
+    success, content = _open_skill_editor(console, debug_mode_container, initial_content)
+    if not success or not content or not content.strip():
+        console.print("[dim]Cancelled.[/dim]")
+        return None
+    path = write_skill(name, content, overwrite=overwrite)
+    console.print(f"[green]{verb} skill '{name}'.[/green] [dim]{path}[/dim]")
+    return path
+
+
+def _handle_skills(chat_manager, console, debug_mode_container, args, cron_sched=None):
+    """Handle /skills command — manage reusable prompt snippets."""
+    from core.skills import (
+        SkillError,
+        activate_skill,
+        get_skills_dir,
+        read_skill,
+        remove_skill,
+        validate_skill_name,
+        write_skill,
+    )
+
+    if not args or not args.strip():
+        _skills_list(console)
+        return CommandResult(status="handled")
+
+    args_clean = args.strip()
+    parts = args_clean.split(maxsplit=2)
+    subcmd = parts[0].lower()
+
+    try:
+        if subcmd in ("help", "-h", "--help"):
+            _print_skills_usage(console)
+            return CommandResult(status="handled")
+
+        if subcmd in ("list", "ls"):
+            list_parts = args_clean.split(maxsplit=1)
+            query = list_parts[1] if len(list_parts) > 1 else None
+            _skills_list(console, query=query)
+            return CommandResult(status="handled")
+
+        if subcmd == "dir":
+            console.print(str(get_skills_dir()))
+            return CommandResult(status="handled")
+
+        if subcmd == "show":
+            if len(parts) < 2:
+                console.print("[red]Usage: /skills show <name>[/red]")
+                return CommandResult(status="handled")
+            name = validate_skill_name(parts[1])
+            content = read_skill(name, strip_heading=False)
+            console.print(Markdown(left_align_headings(content), code_theme=MonokaiDarkBGStyle, justify="left"))
+            return CommandResult(status="handled")
+
+        if subcmd in ("load", "use"):
+            if len(parts) < 2:
+                console.print(f"[red]Usage: /skills {subcmd} <name>[/red]")
+                return CommandResult(status="handled")
+            name = validate_skill_name(parts[1])
+            tokens = activate_skill(chat_manager, name, read_skill(name))
+            console.print(f"[green]Activated skill '{name}' for this chat.[/green] [dim](~{tokens:,} tokens)[/dim]")
+            return CommandResult(status="handled")
+
+        if subcmd in ("remove", "rm", "delete"):
+            if len(parts) < 2:
+                console.print("[red]Usage: /skills remove <name>[/red]")
+                return CommandResult(status="handled")
+            name = validate_skill_name(parts[1])
+            from rich.prompt import Confirm
+            if not Confirm.ask(f"Remove skill '{name}'?", default=False):
+                console.print("[dim]Cancelled.[/dim]")
+                return CommandResult(status="handled")
+            remove_skill(name)
+            console.print(f"[green]Removed skill '{name}'.[/green]")
+            return CommandResult(status="handled")
+
+        if subcmd == "edit":
+            if len(parts) < 2:
+                console.print("[red]Usage: /skills edit <name>[/red]")
+                return CommandResult(status="handled")
+            name = validate_skill_name(parts[1])
+            try:
+                initial_content = read_skill(name, strip_heading=False)
+            except SkillError:
+                initial_content = f"# {name}\n\n"
+            _write_skill_from_editor(
+                console,
+                debug_mode_container,
+                name,
+                initial_content,
+                overwrite=True,
+                verb="Saved",
+            )
+            return CommandResult(status="handled")
+
+        if subcmd in ("add", "create", "new"):
+            if len(parts) < 2:
+                console.print(f"[red]Usage: /skills {subcmd} <name> [prompt][/red]")
+                return CommandResult(status="handled")
+            name = validate_skill_name(parts[1])
+            if len(parts) >= 3:
+                path = write_skill(name, parts[2], overwrite=False)
+                console.print(f"[green]Created skill '{name}'.[/green] [dim]{path}[/dim]")
+                return CommandResult(status="handled")
+            _write_skill_from_editor(
+                console,
+                debug_mode_container,
+                name,
+                f"# {name}\n\n",
+                overwrite=False,
+                verb="Created",
+            )
+            return CommandResult(status="handled")
+
+        if subcmd == "modify":
+            cmd_parts = args_clean.split(maxsplit=2)
+            if len(cmd_parts) < 2:
+                console.print("[red]Usage: /skills modify <name> [prompt][/red]")
+                return CommandResult(status="handled")
+            name = validate_skill_name(cmd_parts[1])
+            if len(cmd_parts) < 3:
+                _write_skill_from_editor(
+                    console,
+                    debug_mode_container,
+                    name,
+                    read_skill(name, strip_heading=False),
+                    overwrite=True,
+                    verb="Updated",
+                )
+                return CommandResult(status="handled")
+            read_skill(name)
+            path = write_skill(name, cmd_parts[2], overwrite=True)
+            console.print(f"[green]Updated skill '{name}'.[/green] [dim]{path}[/dim]")
+            return CommandResult(status="handled")
+
+        if len(parts) >= 2:
+            name = validate_skill_name(parts[0])
+            _, body = args_clean.split(maxsplit=1)
+            path = write_skill(name, body, overwrite=False)
+            console.print(f"[green]Created skill '{name}'.[/green] [dim]{path}[/dim]")
+            return CommandResult(status="handled")
+
+        console.print("[red]Usage: /skills add <name> [prompt][/red]")
+        console.print("[dim]Run [bold #5F9EA0]/skills help[/bold #5F9EA0] for all commands.[/dim]")
+        return CommandResult(status="handled")
+
+    except SkillError as e:
+        console.print(f"[red]{e}[/red]")
+        return CommandResult(status="handled")
+    except Exception as e:
+        console.print(f"[red]Skills command failed: {e}[/red]")
+        return CommandResult(status="handled")
+
+
 def _handle_obsidian_init(console, obsidian_settings):
     """Handle /obsidian init — scaffold project folder structure in vault."""
     if not obsidian_settings.is_active():
@@ -2658,9 +3061,35 @@ _COMMAND_HANDLERS = {
     "/cd": _handle_cd,
     "/setup": _handle_setup,
     "/cron": _handle_cron,
+    "/prompt": _handle_prompt,
+    "/skills": _handle_skills,
 }
 
 
+def _handle_shell_command(console, command):
+    """Execute a shell command prefixed with : and display output."""
+    from utils.settings import tool_settings
+    try:
+        result = subprocess.run(
+            ["/bin/sh", "-c", command], capture_output=True, text=True,
+            encoding="utf-8", errors="replace", timeout=tool_settings.command_timeout_sec,
+        )
+        output = ((result.stdout or "") + (result.stderr or "")).strip() or "(no output)"
+        lines = output.splitlines()
+        if len(lines) > 200:
+            output = "\n".join(lines[:100]) + f"\n\n... ({len(lines) - 200} lines omitted) ...\n\n" + "\n".join(lines[-100:])
+        console.print()
+        if result.returncode != 0:
+            console.print(f"[red]exit code: {result.returncode}[/red]")
+        console.print(output)
+        console.print()
+    except subprocess.TimeoutExpired:
+        console.print(f"[red]Command timed out after {tool_settings.command_timeout_sec}s[/red]")
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+    return CommandResult(status="handled")
+
+
 def process_command(chat_manager, user_input, console, debug_mode_container, cron_scheduler=None):
     """Process command and optionally return replacement content.
 
@@ -2681,6 +3110,14 @@ def process_command(chat_manager, user_input, console, debug_mode_container, cro
     cmd = parts[0].lower()
     args = parts[1] if len(parts) > 1 else None
 
+    # Shell command prefix (:command)
+    if user_input.startswith(":"):
+        shell_cmd = user_input[1:].strip()
+        if shell_cmd:
+            result = _handle_shell_command(console, shell_cmd)
+            return (result.status, result.replacement_input)
+        return ("handled", None)
+
     # Look up handler in registry
     handler = _COMMAND_HANDLERS.get(cmd)
     if handler: